@kensio/yulin 1.21.3 → 1.21.5

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 {};

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

@@ -1,4 +1,6 @@
 import { simS3ObjectETag } from "./s3-object-etag.js";
+import { SimS3ObjectTagSet } from "./s3-object-tags.js";
+import { simS3DefaultStorageClass, } from "./s3-storage-class.js";
 import { simS3SystemMetadataOutput, simS3UserDefinedMetadata, } from "./s3-system-metadata-read.js";
 /**
  * Simulated S3 object metadata.
@@ -33,16 +35,45 @@ export class SimS3Object {
     key;
     body;
     metadata;
+    storageClass;
+    serverSideEncryption;
+    tags;
     writtenAt;
     givenETag;
     constructor(properties = {}) {
-        const { key = "object.json", body = Buffer.alloc(0), metadata = new SimS3ObjectMetadata(), lastModified = new Date(), } = properties;
+        const { key = "object.json", body = Buffer.alloc(0), metadata = new SimS3ObjectMetadata(), lastModified = new Date(), storageClass = simS3DefaultStorageClass, tags = SimS3ObjectTagSet.empty(), } = properties;
         this.key = key;
         this.body = body;
         this.metadata = metadata;
+        this.storageClass = storageClass;
+        this.serverSideEncryption = properties.serverSideEncryption;
+        this.tags = tags;
         this.writtenAt = new Date(lastModified);
         this.givenETag = properties.etag;
     }
+    /**
+     * 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) {
+        return this.with({ storageClass });
+    }
+    /**
+     * 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) {
+        return this.with({ tags });
+    }
     /**
      * When S3 last wrote these bytes.
      *
@@ -74,4 +105,24 @@ export class SimS3Object {
     get etag() {
         return this.givenETag ?? simS3ObjectETag(this.body);
     }
+    /**
+     * 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.
+     */
+    with(changed) {
+        return new SimS3Object({
+            key: this.key,
+            body: this.body,
+            metadata: this.metadata,
+            lastModified: this.writtenAt,
+            storageClass: this.storageClass,
+            serverSideEncryption: this.serverSideEncryption,
+            tags: this.tags,
+            ...(this.givenETag !== undefined && { etag: this.givenETag }),
+            ...changed,
+        });
+    }
 }

package/dist/service/s3/object/s3-server-side-encryption.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The server-side encryption algorithms S3 applies to an Object.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html
+ */
+export declare const simS3ServerSideEncryptionAlgorithms: readonly ["AES256", "aws:kms", "aws:kms:dsse"];
+/**
+ * One server-side encryption algorithm.
+ */
+export type SimS3ServerSideEncryption = (typeof simS3ServerSideEncryptionAlgorithms)[number];
+/**
+ * The encryption every Bucket applies to an Object whose write named none.
+ *
+ * Real S3 has encrypted every new Object with SSE-S3 since January 2023, and
+ * reports `AES256` for one written into a Bucket carrying no default of its
+ * own. Nothing is encrypted here. The bytes are stored as they arrive, and this
+ * is what a read says about them.
+ */
+export declare const simS3DefaultServerSideEncryption: SimS3ServerSideEncryption;
+/**
+ * Read the encryption a request or a Bucket configuration named, refusing an
+ * algorithm S3 does not apply.
+ *
+ * Real S3 answers `InvalidArgument` for an unsupported algorithm on a write.
+ */
+export declare function simS3ServerSideEncryptionFrom(value: string | undefined, context: string): SimS3ServerSideEncryption | undefined;
+/**
+ * Whether a value names a server-side encryption algorithm.
+ */
+export declare function isSimS3ServerSideEncryption(value: string): value is SimS3ServerSideEncryption;

package/dist/service/s3/object/s3-server-side-encryption.js

@@ -0,0 +1,42 @@
+import { SimS3InvalidArgument } from "../error/sim-s3.error.js";
+/**
+ * The server-side encryption algorithms S3 applies to an Object.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html
+ */
+export const simS3ServerSideEncryptionAlgorithms = [
+    "AES256",
+    "aws:kms",
+    "aws:kms:dsse",
+];
+/**
+ * The encryption every Bucket applies to an Object whose write named none.
+ *
+ * Real S3 has encrypted every new Object with SSE-S3 since January 2023, and
+ * reports `AES256` for one written into a Bucket carrying no default of its
+ * own. Nothing is encrypted here. The bytes are stored as they arrive, and this
+ * is what a read says about them.
+ */
+export const simS3DefaultServerSideEncryption = "AES256";
+/**
+ * Read the encryption a request or a Bucket configuration named, refusing an
+ * algorithm S3 does not apply.
+ *
+ * Real S3 answers `InvalidArgument` for an unsupported algorithm on a write.
+ */
+export function simS3ServerSideEncryptionFrom(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isSimS3ServerSideEncryption(value)) {
+        throw new SimS3InvalidArgument(`${value} is not a server-side encryption algorithm for ${context}. ` +
+            `It is one of ${simS3ServerSideEncryptionAlgorithms.join(", ")}.`);
+    }
+    return value;
+}
+/**
+ * Whether a value names a server-side encryption algorithm.
+ */
+export function isSimS3ServerSideEncryption(value) {
+    return simS3ServerSideEncryptionAlgorithms.includes(value);
+}

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

@@ -0,0 +1,45 @@
+/**
+ * The storage class S3 puts an Object in when the write names none.
+ *
+ * Reported rather than omitted from a listing, because a listing that leaves it
+ * out reads as an Object of unknown class. Real S3 answers `STANDARD` there and
+ * leaves the `x-amz-storage-class` header off a read of one, which is what
+ * `simS3ReportedStorageClass` is for.
+ */
+export declare const simS3DefaultStorageClass = "STANDARD";
+/**
+ * The storage classes an Object can be in.
+ *
+ * These are the ones a write can name or a lifecycle rule can transition to.
+ * Nothing here changes what a read costs or how long it takes, so the class is
+ * a fact about the Object that S3 reports and applies its rules to.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html
+ */
+export declare const simS3StorageClasses: readonly ["STANDARD", "REDUCED_REDUNDANCY", "STANDARD_IA", "ONEZONE_IA", "INTELLIGENT_TIERING", "GLACIER_IR", "GLACIER", "DEEP_ARCHIVE", "EXPRESS_ONEZONE", "OUTPOSTS", "SNOW"];
+/**
+ * One storage class an Object can be in.
+ */
+export type SimS3StorageClass = (typeof simS3StorageClasses)[number];
+/**
+ * Read the storage class a request named, refusing one S3 has no such class
+ * for.
+ *
+ * A request naming none leaves the Object in the default class. Real S3
+ * answers `InvalidStorageClass` for a name it does not know, and does it
+ * before storing anything.
+ */
+export declare function simS3StorageClassFrom(value: string | undefined, context: string): SimS3StorageClass | undefined;
+/**
+ * The storage class a read of an Object reports, which is nothing for one in
+ * the default class.
+ *
+ * Real S3 leaves `x-amz-storage-class` off a `GetObject` or a `HeadObject`
+ * response for a Standard Object, and sets it for every other class. A listing
+ * is the other way around and always carries one.
+ */
+export declare function simS3ReportedStorageClass(storageClass: SimS3StorageClass): SimS3StorageClass | undefined;
+/**
+ * Whether a value names a storage class.
+ */
+export declare function isSimS3StorageClass(value: string): value is SimS3StorageClass;

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

@@ -0,0 +1,67 @@
+import { SimS3InvalidStorageClass } from "../error/sim-s3.error.js";
+/**
+ * The storage class S3 puts an Object in when the write names none.
+ *
+ * Reported rather than omitted from a listing, because a listing that leaves it
+ * out reads as an Object of unknown class. Real S3 answers `STANDARD` there and
+ * leaves the `x-amz-storage-class` header off a read of one, which is what
+ * `simS3ReportedStorageClass` is for.
+ */
+export const simS3DefaultStorageClass = "STANDARD";
+/**
+ * The storage classes an Object can be in.
+ *
+ * These are the ones a write can name or a lifecycle rule can transition to.
+ * Nothing here changes what a read costs or how long it takes, so the class is
+ * a fact about the Object that S3 reports and applies its rules to.
+ *
+ * https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html
+ */
+export const simS3StorageClasses = [
+    simS3DefaultStorageClass,
+    "REDUCED_REDUNDANCY",
+    "STANDARD_IA",
+    "ONEZONE_IA",
+    "INTELLIGENT_TIERING",
+    "GLACIER_IR",
+    "GLACIER",
+    "DEEP_ARCHIVE",
+    "EXPRESS_ONEZONE",
+    "OUTPOSTS",
+    "SNOW",
+];
+/**
+ * Read the storage class a request named, refusing one S3 has no such class
+ * for.
+ *
+ * A request naming none leaves the Object in the default class. Real S3
+ * answers `InvalidStorageClass` for a name it does not know, and does it
+ * before storing anything.
+ */
+export function simS3StorageClassFrom(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isSimS3StorageClass(value)) {
+        throw new SimS3InvalidStorageClass(`${value} is not an S3 storage class for ${context}. It is one of ` +
+            `${simS3StorageClasses.join(", ")}.`);
+    }
+    return value;
+}
+/**
+ * The storage class a read of an Object reports, which is nothing for one in
+ * the default class.
+ *
+ * Real S3 leaves `x-amz-storage-class` off a `GetObject` or a `HeadObject`
+ * response for a Standard Object, and sets it for every other class. A listing
+ * is the other way around and always carries one.
+ */
+export function simS3ReportedStorageClass(storageClass) {
+    return storageClass === simS3DefaultStorageClass ? undefined : storageClass;
+}
+/**
+ * Whether a value names a storage class.
+ */
+export function isSimS3StorageClass(value) {
+    return simS3StorageClasses.includes(value);
+}