ContentType  string            `json:"contentType,omitempty"`
	UserMetadata map[string]string `json:"userMetadata,omitempty"`
	VersionID    string            `json:"versionId,omitempty"`
	Sequencer    string            `json:"sequencer"`
}

// Metadata represents event metadata.
type Metadata struct {
	SchemaVersion   string `json:"s3SchemaVersion"`
	ConfigurationID string `json:"configurationId"`

				ARN:           policy.ResourceARNPrefix + args.BucketName,
			},
			Object: event.Object{
				Key:       keyName,
				VersionID: args.Object.VersionID,
				Sequencer: uniqueID,
			},
		},
		Source: event.Source{
			Host:      args.Host,
			UserAgent: args.UserAgent,
		},
	}

	isRemovedEvent := args.EventName == event.ObjectRemovedDelete ||

 *
 * <p>Each mapping item consists of one or more input character sequences that are mapped to a single output
 * character sequence. The mapping supports both original values and new values for update operations.</p>
 */
public class CharMappingItem extends DictionaryItem {
    /**
     * Array of input character sequences that will be mapped to the output sequence.
     * These represent the original/current input values for this mapping rule.

        return sequenceOf(directory)
    }

    private
    fun someClassesInDefaultPackage(): Sequence<Path> {
        val directory = projectDir.resolve("classes-default")

        DEFAULT_EXCLUDES_FOR_TEST.forEachIndexed { i, pkg ->
            touchFile(directory.resolve("$pkg/Foo$i.class"))
        }

        return sequenceOf(directory)
    }

    private

 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link
 * Iterator#remove} operations. This utility takes the brute-force approach of trying <i>all</i>
 * possible sequences of these operations, up to a given number of steps. So, if the caller

 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link
 * Iterator#remove} operations. This utility takes the brute-force approach of trying <i>all</i>
 * possible sequences of these operations, up to a given number of steps. So, if the caller

    private
    fun sourceNamesFrom(entry: File): Sequence<String> =
        when {
            entry.isClassPathArchive -> sourceNamesFromJar(entry)
            entry.isDirectory -> sourceNamesFromDir(entry)
            else -> emptySequence()
        }

    private
    fun sourceNamesFromJar(jar: File): Sequence<String> =
        openJarFile(jar).run {
            entries().asSequence()

    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isSuppressDropSequence: (NotRequired - Default false)
    #  You can suppress dropping sequences at initializing schema.
    #
    #; isSuppressDropSequence = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

   * ```
   * [5] EXPLICIT UTF8String
   * ```
   *
   * @param forceConstructed non-null to set the constructed bit to the specified value, even if the
   *     writing process sets something else. This is used to encode SEQUENCES in values that are
   *     declared to have non-constructed values, like OCTET STRING values.
   */
  @Suppress("UNCHECKED_CAST") // read() produces a single element of the expected type.
  fun withExplicitBox(

    }

    /**
     * Sets the sequence number for this heartbeat.
     * The sequence number should be incremented for each heartbeat request.
     *
     * @param sequenceNumber the sequence number
     */
    public void setSequenceNumber(long sequenceNumber) {
        this.sequenceNumber = sequenceNumber;
    }

    /**
     * Gets the sequence number.
     *
     * @return the sequence number
     */