@kensio/yulin 1.21.2 → 1.21.4

package/dist/service/s3/notification/sim-s3-object-notifier.d.ts

@@ -1,6 +1,6 @@
 import type { BackgroundScheduler } from "../../../util/background/background.js";
 import type { SimS3NotificationDestinations } from "./destination/sim-s3-notification-destination.js";
-import { type SimS3ObjectCreatedInput, type SimS3ObjectRemovedInput } from "./event/sim-s3-object-event-builder.js";
+import { type SimS3ObjectCreatedInput, type SimS3ObjectRemovedInput, type SimS3ObjectTaggedInput } from "./event/sim-s3-object-event-builder.js";
 import type { SimS3NotificationDeliveryFailure } from "./sim-s3-notification-failures.js";
 interface SimS3ObjectNotifierProperties {
     readonly destinations: SimS3NotificationDestinations;
@@ -29,6 +29,10 @@ export declare class SimS3ObjectNotifier {
      * Raise an Object creation, as whichever kind of creation it was.
      */
     objectCreated(input: SimS3ObjectCreatedInput): void;
+    /**
+     * Raise a change to an Object's tags, as whichever kind of change it was.
+     */
+    objectTagged(input: SimS3ObjectTaggedInput): void;
     /**
      * Raise an Object removal, as whichever kind of removal it was.
      */

package/dist/service/s3/notification/sim-s3-object-notifier.js

@@ -36,6 +36,12 @@ export class SimS3ObjectNotifier {
     objectCreated(input) {
         this.schedule.matching(input.bucket, input.eventName, input.object.key, () => this.events.forCreated(input));
     }
+    /**
+     * Raise a change to an Object's tags, as whichever kind of change it was.
+     */
+    objectTagged(input) {
+        this.schedule.matching(input.bucket, input.eventName, input.object.key, () => this.events.forTagged(input));
+    }
     /**
      * Raise an Object removal, as whichever kind of removal it was.
      */

package/dist/service/s3/object/s3-key-encoding.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An Object key in the encoded form S3 hands one back in.
+ *
+ * S3 form-URL-encodes a key, so a space becomes a plus sign, while the slashes
+ * that make up a key prefix stay as they are. An event notification record
+ * carries a key this way, and so does a listing that asked for one.
+ *
+ * The encoding is what lets a key hold a character XML cannot carry. An
+ * unencoded key holding a control character is a document no parser will read,
+ * which is the reason `EncodingType` exists.
+ */
+export declare function simS3EncodedKey(key: string): string;

package/dist/service/s3/object/s3-key-encoding.js

@@ -0,0 +1,14 @@
+/**
+ * An Object key in the encoded form S3 hands one back in.
+ *
+ * S3 form-URL-encodes a key, so a space becomes a plus sign, while the slashes
+ * that make up a key prefix stay as they are. An event notification record
+ * carries a key this way, and so does a listing that asked for one.
+ *
+ * The encoding is what lets a key hold a character XML cannot carry. An
+ * unencoded key holding a control character is a document no parser will read,
+ * which is the reason `EncodingType` exists.
+ */
+export function simS3EncodedKey(key) {
+    return encodeURIComponent(key).replaceAll("%20", "+").replaceAll("%2F", "/");
+}

package/dist/service/s3/object/s3-listing-encoding.d.ts

@@ -0,0 +1,42 @@
+import type { SimS3CommonPrefix } from "./s3-common-prefix.js";
+import type { SimS3ObjectSummary } from "./s3-object-summary.js";
+/**
+ * How a listing writes the keys it answers with.
+ *
+ * A listing hands back keys, the prefix and delimiter it was asked for, and the
+ * marker the next page starts at. All of them are keys or parts of one, so all
+ * of them are encoded together or none of them are. That is what this decides,
+ * once, for the whole page.
+ *
+ * A listing that asked for no encoding is answered with the keys as they are
+ * stored, which is what almost every caller wants and what every caller got
+ * before `EncodingType` was read at all.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html
+ */
+export declare class SimS3ListingEncoding {
+    /**
+     * The encoding type to report back, which real S3 echoes only when the
+     * listing asked for one.
+     */
+    readonly encodingType: string | undefined;
+    /**
+     * A value real S3 does not have is refused rather than quietly treated as no
+     * encoding, since a caller misspelling it would otherwise decode keys that
+     * were never encoded.
+     */
+    constructor(encodingType?: string);
+    /**
+     * One key, prefix, delimiter or marker as the listing carries it.
+     */
+    value(value: string | undefined): string | undefined;
+    /**
+     * The Objects on a page, each under the key the listing carries.
+     */
+    summaries(summaries: SimS3ObjectSummary[] | undefined): SimS3ObjectSummary[] | undefined;
+    /**
+     * The folders a page rolled keys up into, each under the prefix the listing
+     * carries.
+     */
+    commonPrefixes(commonPrefixes: SimS3CommonPrefix[] | undefined): SimS3CommonPrefix[] | undefined;
+}

package/dist/service/s3/object/s3-listing-encoding.js

@@ -0,0 +1,75 @@
+import { SimS3InvalidArgument } from "../error/sim-s3.error.js";
+import { simS3EncodedKey } from "./s3-key-encoding.js";
+/**
+ * The only encoding a listing can ask for, which is the only one real S3 has.
+ */
+const urlEncodingType = "url";
+/**
+ * How a listing writes the keys it answers with.
+ *
+ * A listing hands back keys, the prefix and delimiter it was asked for, and the
+ * marker the next page starts at. All of them are keys or parts of one, so all
+ * of them are encoded together or none of them are. That is what this decides,
+ * once, for the whole page.
+ *
+ * A listing that asked for no encoding is answered with the keys as they are
+ * stored, which is what almost every caller wants and what every caller got
+ * before `EncodingType` was read at all.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html
+ */
+export class SimS3ListingEncoding {
+    /**
+     * The encoding type to report back, which real S3 echoes only when the
+     * listing asked for one.
+     */
+    encodingType;
+    /**
+     * A value real S3 does not have is refused rather than quietly treated as no
+     * encoding, since a caller misspelling it would otherwise decode keys that
+     * were never encoded.
+     */
+    constructor(encodingType) {
+        if (encodingType !== undefined && encodingType !== urlEncodingType) {
+            throw new SimS3InvalidArgument(`Not an EncodingType real S3 has: ${encodingType}. ` +
+                `The only one is "${urlEncodingType}".`);
+        }
+        this.encodingType = encodingType;
+    }
+    /**
+     * One key, prefix, delimiter or marker as the listing carries it.
+     */
+    value(value) {
+        if (value === undefined || this.encodingType === undefined) {
+            return value;
+        }
+        return simS3EncodedKey(value);
+    }
+    /**
+     * The Objects on a page, each under the key the listing carries.
+     */
+    summaries(summaries) {
+        if (summaries === undefined || this.encodingType === undefined) {
+            return summaries;
+        }
+        return summaries.map((summary) => 
+        /* v8 ignore next -- a listed Object always has a key */
+        summary.Key === undefined
+            ? summary
+            : { ...summary, Key: simS3EncodedKey(summary.Key) });
+    }
+    /**
+     * The folders a page rolled keys up into, each under the prefix the listing
+     * carries.
+     */
+    commonPrefixes(commonPrefixes) {
+        if (commonPrefixes === undefined || this.encodingType === undefined) {
+            return commonPrefixes;
+        }
+        return commonPrefixes.map((commonPrefix) => 
+        /* v8 ignore next -- a rolled-up folder always has a prefix */
+        commonPrefix.Prefix === undefined
+            ? commonPrefix
+            : { Prefix: simS3EncodedKey(commonPrefix.Prefix) });
+    }
+}

package/dist/service/s3/object/s3-object-response-headers.d.ts

@@ -4,6 +4,16 @@
 export interface SimS3ObjectResponseDescription {
     /** The system metadata S3 was told when the Object was written. */
     readonly metadata?: Readonly<Record<string, string>> | undefined;
+    /**
+     * The metadata the caller attached to the Object, under the keys it used
+     * rather than the prefixed names the headers carry.
+     */
+    readonly userMetadata?: Readonly<Record<string, string>> | undefined;
+    /**
+     * The headers the read asked to be served in place of the Object's own,
+     * under the same names, from its `response-` parameters.
+     */
+    readonly overrides?: Readonly<Record<string, string>> | undefined;
     /** The length of the body being served, in bytes. */
     readonly bodyLength: number;
     /** The Object's ETag, quoted as an HTTP entity tag. */
@@ -15,6 +25,13 @@ export interface SimS3ObjectResponseDescription {
      * of them rather than all of them.
      */
     readonly contentRange?: string | undefined;
+    /**
+     * The storage class the Object is in, for one outside the default class.
+     * Real S3 leaves the header off a Standard Object.
+     */
+    readonly storageClass?: string | undefined;
+    /** The encryption S3 applied when it stored the Object. */
+    readonly serverSideEncryption?: string | undefined;
 }
 /**
  * The headers S3 sets on a read from what it was told when the Object was
@@ -26,6 +43,17 @@ export interface SimS3ObjectResponseDescription {
  * client can decode. `Cache-Control` matters for a different reason, being the
  * only one of these a caller can set per Object rather than per response.
  *
+ * `x-amz-storage-class` and `x-amz-server-side-encryption` say where and how
+ * S3 keeps the Object. The class is set for an Object outside the default one,
+ * as real S3 sets it, and the encryption is set for every Object S3 stored
+ * itself.
+ *
+ * User-defined metadata goes back out under the `x-amz-meta-` prefix S3 sends
+ * it with, one header per entry. The prefix is what keeps a caller's own key
+ * apart from a header S3 sets itself, so an Object holding a `content-type`
+ * key is served an `x-amz-meta-content-type` header alongside its own content
+ * type rather than in place of it.
+ *
  * `ETag` and `Last-Modified` are not metadata but facts about the stored bytes,
  * and are what makes a conditional request or a content-hash comparison
  * possible over HTTP. `Content-Range` is a fact about the response rather than
@@ -37,3 +65,15 @@ export interface SimS3ObjectResponseDescription {
  * https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingMetadata.html
  */
 export declare function simS3ObjectResponseHeaders(description: SimS3ObjectResponseDescription): Record<string, string>;
+/**
+ * The response headers a read asked to be served in place of the Object's own.
+ *
+ * Real S3 has one of these per system metadata header, named after it, so they
+ * are read by the same list rather than spelled out again. `Content-Type` and
+ * `Content-Disposition` are the two worth having: a presigned URL naming them
+ * decides whether the browser opens the file or saves it, and under what name,
+ * without anything being written to the Object.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html
+ */
+export declare function simS3ResponseHeaderOverrides(query: URLSearchParams): Record<string, string>;

package/dist/service/s3/object/s3-object-response-headers.js

@@ -1,4 +1,4 @@
-import { simS3SystemMetadataHeaders } from "./s3-system-metadata.js";
+import { simS3SystemMetadataHeaders, simS3UserMetadataPrefix, } from "./s3-system-metadata.js";
 /**
  * The headers S3 sets on a read from what it was told when the Object was
  * written.
@@ -9,6 +9,17 @@ import { simS3SystemMetadataHeaders } from "./s3-system-metadata.js";
  * client can decode. `Cache-Control` matters for a different reason, being the
  * only one of these a caller can set per Object rather than per response.
  *
+ * `x-amz-storage-class` and `x-amz-server-side-encryption` say where and how
+ * S3 keeps the Object. The class is set for an Object outside the default one,
+ * as real S3 sets it, and the encryption is set for every Object S3 stored
+ * itself.
+ *
+ * User-defined metadata goes back out under the `x-amz-meta-` prefix S3 sends
+ * it with, one header per entry. The prefix is what keeps a caller's own key
+ * apart from a header S3 sets itself, so an Object holding a `content-type`
+ * key is served an `x-amz-meta-content-type` header alongside its own content
+ * type rather than in place of it.
+ *
  * `ETag` and `Last-Modified` are not metadata but facts about the stored bytes,
  * and are what makes a conditional request or a content-hash comparison
  * possible over HTTP. `Content-Range` is a fact about the response rather than
@@ -24,11 +35,16 @@ export function simS3ObjectResponseHeaders(description) {
         "content-length": String(description.bodyLength),
     };
     for (const header of simS3SystemMetadataHeaders) {
-        const value = description.metadata?.[header.name];
+        const value = description.overrides?.[header.name] ??
+            description.metadata?.[header.name];
         if (value !== undefined) {
             headers[header.name] = value;
         }
     }
+    const userDefined = Object.entries(description.userMetadata ?? {});
+    for (const [key, value] of userDefined) {
+        headers[`${simS3UserMetadataPrefix}${key}`] = value;
+    }
     if (description.etag !== undefined) {
         headers["etag"] = description.etag;
     }
@@ -38,5 +54,36 @@ export function simS3ObjectResponseHeaders(description) {
     if (description.contentRange !== undefined) {
         headers["content-range"] = description.contentRange;
     }
+    if (description.storageClass !== undefined) {
+        headers["x-amz-storage-class"] = description.storageClass;
+    }
+    if (description.serverSideEncryption !== undefined) {
+        headers["x-amz-server-side-encryption"] = description.serverSideEncryption;
+    }
     return headers;
 }
+/**
+ * The prefix a read overrides a response header with.
+ */
+const responseOverridePrefix = "response-";
+/**
+ * The response headers a read asked to be served in place of the Object's own.
+ *
+ * Real S3 has one of these per system metadata header, named after it, so they
+ * are read by the same list rather than spelled out again. `Content-Type` and
+ * `Content-Disposition` are the two worth having: a presigned URL naming them
+ * decides whether the browser opens the file or saves it, and under what name,
+ * without anything being written to the Object.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html
+ */
+export function simS3ResponseHeaderOverrides(query) {
+    const overrides = {};
+    for (const header of simS3SystemMetadataHeaders) {
+        const value = query.get(`${responseOverridePrefix}${header.name}`);
+        if (value !== null) {
+            overrides[header.name] = value;
+        }
+    }
+    return overrides;
+}

package/dist/service/s3/object/s3-object-storage-report.d.ts

@@ -0,0 +1,19 @@
+import type { SimS3Object } from "./s3-object.js";
+import type { SimS3ServerSideEncryption } from "./s3-server-side-encryption.js";
+import { type SimS3StorageClass } from "./s3-storage-class.js";
+/**
+ * What a read says about where and how S3 keeps an Object.
+ */
+export interface SimS3ObjectStorageReport {
+    readonly StorageClass?: SimS3StorageClass;
+    readonly ServerSideEncryption?: SimS3ServerSideEncryption;
+}
+/**
+ * Describe where and how S3 keeps an Object, as `GetObject` and `HeadObject`
+ * report it.
+ *
+ * Real S3 leaves the storage class out of a read of a Standard Object and
+ * reports it for every other class. An Object's encryption is reported
+ * whatever it is, because S3 encrypts every Object it stores.
+ */
+export declare function simS3ObjectStorageReport(object: SimS3Object): SimS3ObjectStorageReport;

package/dist/service/s3/object/s3-object-storage-report.js

@@ -0,0 +1,18 @@
+import { simS3ReportedStorageClass, } from "./s3-storage-class.js";
+/**
+ * Describe where and how S3 keeps an Object, as `GetObject` and `HeadObject`
+ * report it.
+ *
+ * Real S3 leaves the storage class out of a read of a Standard Object and
+ * reports it for every other class. An Object's encryption is reported
+ * whatever it is, because S3 encrypts every Object it stores.
+ */
+export function simS3ObjectStorageReport(object) {
+    const storageClass = simS3ReportedStorageClass(object.storageClass);
+    return {
+        ...(storageClass !== undefined && { StorageClass: storageClass }),
+        ...(object.serverSideEncryption !== undefined && {
+            ServerSideEncryption: object.serverSideEncryption,
+        }),
+    };
+}

package/dist/service/s3/object/s3-object-summary.d.ts

@@ -1,13 +1,5 @@
 import type { SimS3Object } from "./s3-object.js";
-/**
- * The storage class S3 reports for an Object nobody asked to store elsewhere.
- *
- * Storage classes are not simulated, and this is the one real S3 puts an Object
- * in unless told otherwise. It is reported rather than omitted because a
- * listing that leaves it out reads as an Object of unknown class, which is a
- * different thing from a Standard one.
- */
-export declare const simS3DefaultStorageClass = "STANDARD";
+import type { SimS3StorageClass } from "./s3-storage-class.js";
 /**
  * One Object as a listing describes it.
  *
@@ -20,7 +12,7 @@ export interface SimS3ObjectSummary {
     readonly Size?: number;
     readonly ETag?: string;
     readonly LastModified?: Date;
-    readonly StorageClass?: string;
+    readonly StorageClass?: SimS3StorageClass;
 }
 /**
  * Describe a stored Object the way a listing does.

package/dist/service/s3/object/s3-object-summary.js

@@ -1,13 +1,4 @@
 import { simS3QuotedETag } from "./s3-object-etag.js";
-/**
- * The storage class S3 reports for an Object nobody asked to store elsewhere.
- *
- * Storage classes are not simulated, and this is the one real S3 puts an Object
- * in unless told otherwise. It is reported rather than omitted because a
- * listing that leaves it out reads as an Object of unknown class, which is a
- * different thing from a Standard one.
- */
-export const simS3DefaultStorageClass = "STANDARD";
 /**
  * Describe a stored Object the way a listing does.
  *
@@ -21,7 +12,7 @@ export function simS3ObjectSummary(object) {
         Size: object.body.length,
         ETag: simS3QuotedETag(object.etag),
         LastModified: object.lastModified,
-        StorageClass: simS3DefaultStorageClass,
+        StorageClass: object.storageClass,
     };
 }
 /**

package/dist/service/s3/object/s3-object-tags.d.ts

@@ -0,0 +1,61 @@
+/**
+ * One tag on an Object, in the form a request states it and a read hands it
+ * back.
+ */
+export interface SimS3ObjectTag {
+    readonly Key: string;
+    readonly Value: string;
+}
+/**
+ * One tag as it arrives, where a request is free to leave either half out.
+ *
+ * The SDK types both members optional, so a tag naming no key reaches the
+ * simulator and is refused here rather than stored under an empty key.
+ */
+export interface SimS3ObjectTagInput {
+    readonly Key?: string | undefined;
+    readonly Value?: string | undefined;
+}
+/**
+ * The tags one simulated S3 Object carries.
+ *
+ * Held as a map because a tag set is keyed. Real S3 refuses two tags sharing a
+ * key, and every question anything asks of a tag set is about the value under
+ * one. The insertion order is the order the request stated, and a read hands
+ * them back in it.
+ *
+ * A set is built once and never changed, so the Object holding it cannot have
+ * its tags rewritten by whoever was handed them. `PutObjectTagging` replaces
+ * the whole set, which is what real S3 does with one.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-tagging.html
+ */
+export declare class SimS3ObjectTagSet {
+    private readonly held;
+    private constructor();
+    /**
+     * The tag set an Object nobody has tagged carries.
+     */
+    static empty(): SimS3ObjectTagSet;
+    /**
+     * The tag set a request states, refusing one real S3 would not hold.
+     *
+     * Every refusal is checked before anything is stored. An Object is never
+     * left carrying part of a tag set S3 would have rejected whole. The context
+     * names the request, since the same tag set can arrive on a write, on a copy
+     * or on a tagging request of its own.
+     */
+    static from(tags: readonly SimS3ObjectTagInput[], context: string): SimS3ObjectTagSet;
+    /**
+     * The tags, in the order the request that set them stated.
+     */
+    get tags(): readonly SimS3ObjectTag[];
+    /**
+     * Whether this Object carries exactly this tag.
+     *
+     * Both halves have to match, because that is what a lifecycle rule filtering
+     * on a tag asks: a rule for `archive=true` says nothing about an Object
+     * tagged `archive=false`.
+     */
+    has(key: string, value: string): boolean;
+}

package/dist/service/s3/object/s3-object-tags.js

@@ -0,0 +1,77 @@
+import { SimS3InvalidTag } from "../error/sim-s3.error.js";
+/**
+ * The most tags real S3 holds against one Object.
+ */
+const simS3MaxObjectTags = 10;
+/**
+ * The tags one simulated S3 Object carries.
+ *
+ * Held as a map because a tag set is keyed. Real S3 refuses two tags sharing a
+ * key, and every question anything asks of a tag set is about the value under
+ * one. The insertion order is the order the request stated, and a read hands
+ * them back in it.
+ *
+ * A set is built once and never changed, so the Object holding it cannot have
+ * its tags rewritten by whoever was handed them. `PutObjectTagging` replaces
+ * the whole set, which is what real S3 does with one.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-tagging.html
+ */
+export class SimS3ObjectTagSet {
+    held;
+    constructor(held) {
+        this.held = held;
+    }
+    /**
+     * The tag set an Object nobody has tagged carries.
+     */
+    static empty() {
+        return new SimS3ObjectTagSet(new Map());
+    }
+    /**
+     * The tag set a request states, refusing one real S3 would not hold.
+     *
+     * Every refusal is checked before anything is stored. An Object is never
+     * left carrying part of a tag set S3 would have rejected whole. The context
+     * names the request, since the same tag set can arrive on a write, on a copy
+     * or on a tagging request of its own.
+     */
+    static from(tags, context) {
+        if (tags.length > simS3MaxObjectTags) {
+            throw new SimS3InvalidTag(`The tag set of ${context} holds ${tags.length} tags. An S3 Object ` +
+                `holds at most ${simS3MaxObjectTags}.`);
+        }
+        const held = new Map();
+        for (const tag of tags) {
+            const key = tag.Key;
+            if (key === undefined || key.length === 0) {
+                throw new SimS3InvalidTag(`A tag of ${context} names no key.`);
+            }
+            if (held.has(key)) {
+                throw new SimS3InvalidTag(`The tag set of ${context} states the key ${key} twice. An S3 ` +
+                    `Object holds one value under each tag key.`);
+            }
+            held.set(key, tag.Value ?? "");
+        }
+        return new SimS3ObjectTagSet(held);
+    }
+    /**
+     * The tags, in the order the request that set them stated.
+     */
+    get tags() {
+        return this.held
+            .entries()
+            .map(([Key, Value]) => ({ Key, Value }))
+            .toArray();
+    }
+    /**
+     * Whether this Object carries exactly this tag.
+     *
+     * Both halves have to match, because that is what a lifecycle rule filtering
+     * on a tag asks: a rule for `archive=true` says nothing about an Object
+     * tagged `archive=false`.
+     */
+    has(key, value) {
+        return this.held.get(key) === value;
+    }
+}

package/dist/service/s3/object/s3-object.d.ts

@@ -1,3 +1,6 @@
+import { SimS3ObjectTagSet } from "./s3-object-tags.js";
+import type { SimS3ServerSideEncryption } from "./s3-server-side-encryption.js";
+import { type SimS3StorageClass } from "./s3-storage-class.js";
 import { type SimS3SystemMetadataOutput } from "./s3-system-metadata-read.js";
 /**
  * Simulated S3 object metadata.
@@ -29,6 +32,22 @@ interface SimS3ObjectProperties {
      * them. Only a multipart upload produces one.
      */
     readonly etag?: string;
+    /**
+     * The storage class the Object is in. An Object nobody asked to store
+     * elsewhere is in the default class.
+     */
+    readonly storageClass?: SimS3StorageClass;
+    /**
+     * The encryption S3 applied when it stored these bytes, from the write or
+     * from the Bucket's default. The bytes are stored as they arrived whatever
+     * this says, and it is what a read reports about them.
+     */
+    readonly serverSideEncryption?: SimS3ServerSideEncryption | undefined;
+    /**
+     * The tags S3 holds against the Object. A write that named none, and an
+     * Object nobody has tagged since, carries an empty set.
+     */
+    readonly tags?: SimS3ObjectTagSet | undefined;
 }
 /**
  * Simulated S3 object.
@@ -37,9 +56,31 @@ export declare class SimS3Object {
     readonly key: string;
     readonly body: Buffer;
     readonly metadata: SimS3ObjectMetadata;
+    readonly storageClass: SimS3StorageClass;
+    readonly serverSideEncryption: SimS3ServerSideEncryption | undefined;
+    readonly tags: SimS3ObjectTagSet;
     private readonly writtenAt;
     private readonly givenETag;
     constructor(properties?: SimS3ObjectProperties);
+    /**
+     * The same Object in another storage class, for a lifecycle rule that has
+     * transitioned it.
+     *
+     * The bytes are shared with the Object this came from. A transition moves
+     * where S3 keeps an Object and leaves the Object itself alone, so its ETag,
+     * its metadata, its tags and the instant it was last written all carry over.
+     */
+    withStorageClass(storageClass: SimS3StorageClass): SimS3Object;
+    /**
+     * The same Object under another tag set, for a tagging request that has
+     * replaced the one it carried.
+     *
+     * Real S3 holds tags against an Object without rewriting it, so nothing else
+     * about it changes: the bytes, the ETag and the instant it was last written
+     * are the ones it already had. A read after tagging reports the same
+     * `LastModified` as a read before it.
+     */
+    withTags(tags: SimS3ObjectTagSet): SimS3Object;
     /**
      * When S3 last wrote these bytes.
      *
@@ -67,5 +108,13 @@ export declare class SimS3Object {
      * about the joined bytes records, so it cannot be recomputed from them.
      */
     get etag(): string;
+    /**
+     * The same Object with one thing about it replaced.
+     *
+     * Everything S3 remembers is carried over by hand rather than by copying the
+     * instance, because an Object holds its write time and its given ETag
+     * privately and a spread would lose both.
+     */
+    private with;
 }
 export {};