@kensio/yulin 1.20.17 → 1.21.1

package/dist/service/s3/command/versioning/sim-s3-versioning-configuration-validation.d.ts

@@ -0,0 +1,13 @@
+import type { SimS3VersioningConfiguration } from "../../bucket/versioning/sim-s3-bucket-versioning.js";
+/**
+ * Refuse a versioning configuration this simulator cannot carry out.
+ *
+ * Real S3 takes `Enabled` and `Suspended` for the status and nothing else, and
+ * there is no request that takes a Bucket back to unversioned. MFA delete
+ * takes `Enabled` and `Disabled`, and a value that is neither is refused here
+ * rather than ignored, because a status S3 would have rejected reads back
+ * looking configured. Asking for it enabled is refused too, since a Bucket
+ * reporting a protection it does not enforce is the wrong answer to the
+ * question a test is asking.
+ */
+export declare function validateSimS3VersioningConfiguration(configuration: SimS3VersioningConfiguration, bucketName: string): void;

package/dist/service/s3/command/versioning/sim-s3-versioning-configuration-validation.js

@@ -0,0 +1,28 @@
+import { SimS3InvalidArgument, SimS3NotImplemented, } from "../../error/sim-s3.error.js";
+/**
+ * Refuse a versioning configuration this simulator cannot carry out.
+ *
+ * Real S3 takes `Enabled` and `Suspended` for the status and nothing else, and
+ * there is no request that takes a Bucket back to unversioned. MFA delete
+ * takes `Enabled` and `Disabled`, and a value that is neither is refused here
+ * rather than ignored, because a status S3 would have rejected reads back
+ * looking configured. Asking for it enabled is refused too, since a Bucket
+ * reporting a protection it does not enforce is the wrong answer to the
+ * question a test is asking.
+ */
+export function validateSimS3VersioningConfiguration(configuration, bucketName) {
+    if (configuration.MFADelete === "Enabled") {
+        throw new SimS3NotImplemented(`Simulated S3 does not enforce MFA delete, so it refuses to report it ` +
+            `enabled on Bucket ${bucketName}.`);
+    }
+    if (configuration.MFADelete !== undefined &&
+        configuration.MFADelete !== "Disabled") {
+        throw new SimS3InvalidArgument(`The MFA delete status ${configuration.MFADelete} is not one S3 ` +
+            `accepts. It takes Enabled or Disabled.`);
+    }
+    if (configuration.Status !== "Enabled" &&
+        configuration.Status !== "Suspended") {
+        throw new SimS3InvalidArgument(`The versioning status ${String(configuration.Status)} is not one S3 ` +
+            `accepts. It takes Enabled or Suspended.`);
+    }
+}

package/dist/service/s3/error/sim-s3-object-lock.error.d.ts

@@ -0,0 +1,22 @@
+import { SimS3Error } from "./sim-s3.error.js";
+/**
+ * Simulated S3 InvalidBucketState error.
+ *
+ * A request real S3 refuses because of how the Bucket is configured rather
+ * than because of anything in the request. Turning Object Lock on over a
+ * Bucket that keeps no versions is the one sim S3 raises it for.
+ */
+export declare class SimS3InvalidBucketState extends SimS3Error {
+    readonly name = "InvalidBucketState";
+    constructor(message: string);
+}
+/**
+ * Simulated S3 ObjectLockConfigurationNotFoundError.
+ *
+ * What real S3 answers a read of the Object Lock configuration of a Bucket
+ * that has never had one, rather than answering with an empty configuration.
+ */
+export declare class SimS3ObjectLockConfigurationNotFound extends SimS3Error {
+    readonly name = "ObjectLockConfigurationNotFoundError";
+    constructor(message: string);
+}

package/dist/service/s3/error/sim-s3-object-lock.error.js

@@ -0,0 +1,26 @@
+import { SimS3Error } from "./sim-s3.error.js";
+/**
+ * Simulated S3 InvalidBucketState error.
+ *
+ * A request real S3 refuses because of how the Bucket is configured rather
+ * than because of anything in the request. Turning Object Lock on over a
+ * Bucket that keeps no versions is the one sim S3 raises it for.
+ */
+export class SimS3InvalidBucketState extends SimS3Error {
+    name = "InvalidBucketState";
+    constructor(message) {
+        super(message, { httpStatusCode: 409 });
+    }
+}
+/**
+ * Simulated S3 ObjectLockConfigurationNotFoundError.
+ *
+ * What real S3 answers a read of the Object Lock configuration of a Bucket
+ * that has never had one, rather than answering with an empty configuration.
+ */
+export class SimS3ObjectLockConfigurationNotFound extends SimS3Error {
+    name = "ObjectLockConfigurationNotFoundError";
+    constructor(message) {
+        super(message, { httpStatusCode: 404 });
+    }
+}

package/dist/service/s3/error/sim-s3.error.d.ts

@@ -37,6 +37,28 @@ export declare class SimS3NotFound extends SimS3Error {
     readonly name = "NotFound";
     constructor(message: string);
 }
+/**
+ * Simulated S3 NoSuchVersion error.
+ *
+ * What real S3 answers when a request names a version id that no version of
+ * that key was ever given. A key that exists with a version id that does not
+ * is this rather than NoSuchKey.
+ */
+export declare class SimS3NoSuchVersion extends SimS3Error {
+    readonly name = "NoSuchVersion";
+    constructor(message: string);
+}
+/**
+ * Simulated S3 MethodNotAllowed error.
+ *
+ * What real S3 answers to a read of a delete marker by its own version id. The
+ * marker exists, so it is not a missing version, and it holds no bytes to
+ * send.
+ */
+export declare class SimS3MethodNotAllowed extends SimS3Error {
+    readonly name = "MethodNotAllowed";
+    constructor(message: string);
+}
 /**
  * Simulated S3 NoSuchBucketPolicy error.
  *

package/dist/service/s3/error/sim-s3.error.js

@@ -40,6 +40,32 @@ export class SimS3NotFound extends SimS3Error {
         super(message, { httpStatusCode: 404 });
     }
 }
+/**
+ * Simulated S3 NoSuchVersion error.
+ *
+ * What real S3 answers when a request names a version id that no version of
+ * that key was ever given. A key that exists with a version id that does not
+ * is this rather than NoSuchKey.
+ */
+export class SimS3NoSuchVersion extends SimS3Error {
+    name = "NoSuchVersion";
+    constructor(message) {
+        super(message, { httpStatusCode: 404 });
+    }
+}
+/**
+ * Simulated S3 MethodNotAllowed error.
+ *
+ * What real S3 answers to a read of a delete marker by its own version id. The
+ * marker exists, so it is not a missing version, and it holds no bytes to
+ * send.
+ */
+export class SimS3MethodNotAllowed extends SimS3Error {
+    name = "MethodNotAllowed";
+    constructor(message) {
+        super(message, { httpStatusCode: 405 });
+    }
+}
 /**
  * Simulated S3 NoSuchBucketPolicy error.
  *

package/dist/service/s3/notification/event/sim-s3-event-records.js

@@ -51,6 +51,9 @@ export function simS3EventRecordsDocument(event, configurationId) {
                         key: simS3EventObjectKey(event.key),
                         ...(event.size !== undefined && { size: event.size }),
                         ...(event.eTag !== undefined && { eTag: event.eTag }),
+                        ...(event.versionId !== undefined && {
+                            versionId: event.versionId,
+                        }),
                         sequencer: event.sequencer,
                     },
                 },

package/dist/service/s3/notification/event/sim-s3-event.type.d.ts

@@ -70,13 +70,15 @@ export interface SimS3EventBucket {
  * The Object an event is about.
  *
  * `size` and `eTag` describe an Object that exists, so a removal record
- * carries neither, as a real S3 removal record does not. The key is
- * form-URL-encoded, as the record carries it: a space is a plus sign, while
- * the slashes of a key prefix stay as they are.
+ * carries neither, as a real S3 removal record does not. `versionId` is
+ * carried by a Bucket keeping versions and left out by one that is not. The
+ * key is form-URL-encoded, as the record carries it: a space is a plus sign,
+ * while the slashes of a key prefix stay as they are.
  */
 export interface SimS3EventObject {
     readonly key: string;
     readonly size?: number | undefined;
     readonly eTag?: string | undefined;
+    readonly versionId?: string | undefined;
     readonly sequencer: string;
 }

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

@@ -17,11 +17,17 @@ export interface SimS3ObjectCreatedInput {
      * rather than as a Put.
      */
     readonly eventName: SimS3ObjectCreatedEvent;
+    /** The version the write was given, on a Bucket keeping versions. */
+    readonly versionId?: string | undefined;
 }
 /**
  * The ways an Object can be created that simulated S3 raises an event for.
  */
 export type SimS3ObjectCreatedEvent = Extract<SimS3NotificationEvent, `s3:ObjectCreated:${string}`>;
+/**
+ * The ways an Object can be removed that simulated S3 raises an event for.
+ */
+export type SimS3ObjectRemovedEvent = Extract<SimS3NotificationEvent, `s3:ObjectRemoved:${string}`>;
 /**
  * An Object key a command has just removed.
  */
@@ -29,6 +35,14 @@ export interface SimS3ObjectRemovedInput {
     readonly bucket: SimS3Bucket;
     readonly key: string;
     readonly caller: SimAwsResolvedCaller;
+    /**
+     * How the key came to be removed, which real S3 distinguishes. A delete on a
+     * versioned Bucket hides the Object behind a marker and arrives as
+     * `s3:ObjectRemoved:DeleteMarkerCreated` rather than as a Delete.
+     */
+    readonly eventName: SimS3ObjectRemovedEvent;
+    /** The version removed, or the marker written, on a Bucket keeping versions. */
+    readonly versionId?: string | undefined;
 }
 /**
  * Something that happened to an Object, before any Bucket configuration has
@@ -41,6 +55,7 @@ export interface SimS3RaisedObjectEvent {
     readonly caller: SimAwsResolvedCaller;
     readonly size?: number | undefined;
     readonly eTag?: string | undefined;
+    readonly versionId?: string | undefined;
 }
 interface SimS3ObjectEventBuilderProperties {
     readonly clock: SimClock;

package/dist/service/s3/notification/event/sim-s3-object-event-builder.js

@@ -28,6 +28,7 @@ export class SimS3ObjectEventBuilder {
             caller: input.caller,
             size: input.object.body.length,
             eTag: input.object.etag,
+            versionId: input.versionId,
         });
     }
     /**
@@ -37,9 +38,10 @@ export class SimS3ObjectEventBuilder {
     forRemoved(input) {
         return this.build({
             bucket: input.bucket,
-            eventName: "s3:ObjectRemoved:Delete",
+            eventName: input.eventName,
             key: input.key,
             caller: input.caller,
+            versionId: input.versionId,
         });
     }
     build(raised) {
@@ -58,6 +60,7 @@ export class SimS3ObjectEventBuilder {
             sequencer: this.sequencers.next(bucketName, raised.key),
             size: raised.size,
             eTag: raised.eTag,
+            versionId: raised.versionId,
         });
     }
 }

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

@@ -12,6 +12,11 @@ interface SimS3ObjectEventProperties {
     readonly sequencer: string;
     readonly size?: number | undefined;
     readonly eTag?: string | undefined;
+    /**
+     * The version this event happened to, on a Bucket keeping versions. A Bucket
+     * without versioning has none, and real S3 leaves the field out for one.
+     */
+    readonly versionId?: string | undefined;
 }
 /**
  * Something that happened to an Object, in terms no destination owns.
@@ -36,6 +41,7 @@ export declare class SimS3ObjectEvent {
     readonly sequencer: string;
     readonly size: number | undefined;
     readonly eTag: string | undefined;
+    readonly versionId: string | undefined;
     constructor(properties: SimS3ObjectEventProperties);
 }
 export {};

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

@@ -21,6 +21,7 @@ export class SimS3ObjectEvent {
     sequencer;
     size;
     eTag;
+    versionId;
     constructor(properties) {
         this.eventName = properties.eventName;
         this.eventTime = properties.eventTime;
@@ -33,5 +34,6 @@ export class SimS3ObjectEvent {
         this.sequencer = properties.sequencer;
         this.size = properties.size;
         this.eTag = properties.eTag;
+        this.versionId = properties.versionId;
     }
 }

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

@@ -30,7 +30,7 @@ export declare class SimS3ObjectNotifier {
      */
     objectCreated(input: SimS3ObjectCreatedInput): void;
     /**
-     * Raise an Object removal.
+     * Raise an Object removal, as whichever kind of removal it was.
      */
     objectRemoved(input: SimS3ObjectRemovedInput): void;
 }

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

@@ -37,9 +37,9 @@ export class SimS3ObjectNotifier {
         this.schedule.matching(input.bucket, input.eventName, input.object.key, () => this.events.forCreated(input));
     }
     /**
-     * Raise an Object removal.
+     * Raise an Object removal, as whichever kind of removal it was.
      */
     objectRemoved(input) {
-        this.schedule.matching(input.bucket, "s3:ObjectRemoved:Delete", input.key, () => this.events.forRemoved(input));
+        this.schedule.matching(input.bucket, input.eventName, input.key, () => this.events.forRemoved(input));
     }
 }

package/dist/service/s3/sdk/sim-s3-sdk-bucket-routes.d.ts

@@ -0,0 +1,10 @@
+import type { SimSdkCommandRoute } from "../../../sdk/index.js";
+import type { SimS3 } from "../sim-s3.js";
+/**
+ * The SDK Commands that act on a Bucket rather than on the Objects in one.
+ *
+ * Split from the Object routes because the router's length tracks the size of
+ * the command surface rather than the complexity of anything in it, and both
+ * halves grow a command at a time.
+ */
+export declare function simS3SdkBucketRoutes(simS3: SimS3): readonly (readonly [string, SimSdkCommandRoute])[];

package/dist/service/s3/sdk/sim-s3-sdk-bucket-routes.js

@@ -0,0 +1,84 @@
+import { simSdkCallerOptions } from "../../../sdk/index.js";
+/**
+ * The SDK Commands that act on a Bucket rather than on the Objects in one.
+ *
+ * Split from the Object routes because the router's length tracks the size of
+ * the command surface rather than the complexity of anything in it, and both
+ * halves grow a command at a time.
+ */
+export function simS3SdkBucketRoutes(simS3) {
+    return [
+        [
+            "CreateBucketCommand",
+            async (command, context) => await simS3.createBucket(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeleteBucketCommand",
+            async (command, context) => await simS3.deleteBucket(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "HeadBucketCommand",
+            async (command, context) => await simS3.headBucket(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "ListBucketsCommand",
+            async (command, context) => await simS3.listBuckets(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutBucketPolicyCommand",
+            async (command, context) => await simS3.putBucketPolicy(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetBucketPolicyCommand",
+            async (command, context) => await simS3.getBucketPolicy(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeleteBucketPolicyCommand",
+            async (command, context) => await simS3.deleteBucketPolicy(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutBucketNotificationConfigurationCommand",
+            async (command, context) => await simS3.putBucketNotificationConfiguration(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetBucketNotificationConfigurationCommand",
+            async (command, context) => await simS3.getBucketNotificationConfiguration(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutBucketLifecycleConfigurationCommand",
+            async (command, context) => await simS3.putBucketLifecycleConfiguration(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetBucketLifecycleConfigurationCommand",
+            async (command, context) => await simS3.getBucketLifecycleConfiguration(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeleteBucketLifecycleCommand",
+            async (command, context) => await simS3.deleteBucketLifecycle(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutBucketVersioningCommand",
+            async (command, context) => await simS3.putBucketVersioning(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetBucketVersioningCommand",
+            async (command, context) => await simS3.getBucketVersioning(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutBucketWebsiteCommand",
+            async (command, context) => await simS3.putBucketWebsite(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutPublicAccessBlockCommand",
+            async (command, context) => await simS3.putPublicAccessBlock(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetPublicAccessBlockCommand",
+            async (command, context) => await simS3.getPublicAccessBlock(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "DeletePublicAccessBlockCommand",
+            async (command, context) => await simS3.deletePublicAccessBlock(command, simSdkCallerOptions(context)),
+        ],
+    ];
+}

package/dist/service/s3/sdk/sim-s3-sdk-command-router.js

@@ -1,4 +1,6 @@
-import { simSdkCallerOptions, simSdkStreamBody } from "../../../sdk/index.js";
+import { simS3SdkBucketRoutes } from "./sim-s3-sdk-bucket-routes.js";
+import { simS3SdkObjectLockRoutes } from "./sim-s3-sdk-object-lock-routes.js";
+import { simS3SdkObjectRoutes } from "./sim-s3-sdk-object-routes.js";
 /**
  * Routes intercepted SDK Commands to one scoped simulated S3 instance.
  */
@@ -6,126 +8,9 @@ export class SimS3SdkCommandRouter {
     routes;
     constructor(simS3) {
         this.routes = new Map([
-            [
-                "CreateBucketCommand",
-                async (command, context) => await simS3.createBucket(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "CopyObjectCommand",
-                async (command, context) => await simS3.copyObject(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "DeleteBucketCommand",
-                async (command, context) => await simS3.deleteBucket(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "DeleteBucketPolicyCommand",
-                async (command, context) => await simS3.deleteBucketPolicy(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "DeleteObjectCommand",
-                async (command, context) => await simS3.deleteObject(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "DeleteObjectsCommand",
-                async (command, context) => await simS3.deleteObjects(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "GetBucketPolicyCommand",
-                async (command, context) => await simS3.getBucketPolicy(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "HeadBucketCommand",
-                async (command, context) => await simS3.headBucket(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "HeadObjectCommand",
-                async (command, context) => await simS3.headObject(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "GetObjectCommand",
-                async (command, context) => await getObjectWithSdkStreamBody(simS3, command, simSdkCallerOptions(context)),
-            ],
-            [
-                "ListBucketsCommand",
-                async (command, context) => await simS3.listBuckets(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "ListObjectsCommand",
-                async (command, context) => await simS3.listObjects(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "ListObjectsV2Command",
-                async (command, context) => await simS3.listObjectsV2(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "PutBucketPolicyCommand",
-                async (command, context) => await simS3.putBucketPolicy(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "PutBucketNotificationConfigurationCommand",
-                async (command, context) => await simS3.putBucketNotificationConfiguration(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "GetBucketNotificationConfigurationCommand",
-                async (command, context) => await simS3.getBucketNotificationConfiguration(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "PutBucketLifecycleConfigurationCommand",
-                async (command, context) => await simS3.putBucketLifecycleConfiguration(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "GetBucketLifecycleConfigurationCommand",
-                async (command, context) => await simS3.getBucketLifecycleConfiguration(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "DeleteBucketLifecycleCommand",
-                async (command, context) => await simS3.deleteBucketLifecycle(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "PutBucketWebsiteCommand",
-                async (command, context) => await simS3.putBucketWebsite(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "PutPublicAccessBlockCommand",
-                async (command, context) => await simS3.putPublicAccessBlock(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "GetPublicAccessBlockCommand",
-                async (command, context) => await simS3.getPublicAccessBlock(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "DeletePublicAccessBlockCommand",
-                async (command, context) => await simS3.deletePublicAccessBlock(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "PutObjectCommand",
-                async (command, context) => await simS3.putObject(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "CreateMultipartUploadCommand",
-                async (command, context) => await simS3.createMultipartUpload(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "UploadPartCommand",
-                async (command, context) => await simS3.uploadPart(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "CompleteMultipartUploadCommand",
-                async (command, context) => await simS3.completeMultipartUpload(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "AbortMultipartUploadCommand",
-                async (command, context) => await simS3.abortMultipartUpload(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "ListMultipartUploadsCommand",
-                async (command, context) => await simS3.listMultipartUploads(command, simSdkCallerOptions(context)),
-            ],
-            [
-                "ListPartsCommand",
-                async (command, context) => await simS3.listParts(command, simSdkCallerOptions(context)),
-            ],
+            ...simS3SdkBucketRoutes(simS3),
+            ...simS3SdkObjectRoutes(simS3),
+            ...simS3SdkObjectLockRoutes(simS3),
         ]);
     }
     /**
@@ -141,14 +26,3 @@ export class SimS3SdkCommandRouter {
         return this.routes.get(commandName);
     }
 }
-/**
- * Get an Object and mix the SDK stream transform methods into its Body, so
- * SDK callers can use e.g. Body.transformToString() as with real S3.
- */
-async function getObjectWithSdkStreamBody(simS3, command, options) {
-    const output = await simS3.getObject(command, options);
-    if (output.Body === undefined) {
-        return output;
-    }
-    return { ...output, Body: simSdkStreamBody(output.Body) };
-}

package/dist/service/s3/sdk/sim-s3-sdk-object-lock-routes.d.ts

@@ -0,0 +1,10 @@
+import type { SimSdkCommandRoute } from "../../../sdk/index.js";
+import type { SimS3 } from "../sim-s3.js";
+/**
+ * The SDK Commands that lock a Bucket and hold the versions in it.
+ *
+ * Two configure the Bucket and two hold one version each, and they route
+ * together because a version can only be held on a Bucket the first two turned
+ * Object Lock on for.
+ */
+export declare function simS3SdkObjectLockRoutes(simS3: SimS3): readonly (readonly [string, SimSdkCommandRoute])[];

package/dist/service/s3/sdk/sim-s3-sdk-object-lock-routes.js

@@ -0,0 +1,28 @@
+import { simSdkCallerOptions } from "../../../sdk/index.js";
+/**
+ * The SDK Commands that lock a Bucket and hold the versions in it.
+ *
+ * Two configure the Bucket and two hold one version each, and they route
+ * together because a version can only be held on a Bucket the first two turned
+ * Object Lock on for.
+ */
+export function simS3SdkObjectLockRoutes(simS3) {
+    return [
+        [
+            "PutObjectLockConfigurationCommand",
+            async (command, context) => await simS3.putObjectLockConfiguration(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "GetObjectLockConfigurationCommand",
+            async (command, context) => await simS3.getObjectLockConfiguration(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutObjectRetentionCommand",
+            async (command, context) => await simS3.putObjectRetention(command, simSdkCallerOptions(context)),
+        ],
+        [
+            "PutObjectLegalHoldCommand",
+            async (command, context) => await simS3.putObjectLegalHold(command, simSdkCallerOptions(context)),
+        ],
+    ];
+}

package/dist/service/s3/sdk/sim-s3-sdk-object-routes.d.ts

@@ -0,0 +1,7 @@
+import type { SimSdkCommandRoute } from "../../../sdk/index.js";
+import type { SimS3 } from "../sim-s3.js";
+/**
+ * The SDK Commands that act on the Objects in a Bucket, the multipart uploads
+ * that build one, and the versions a Bucket keeps of them.
+ */
+export declare function simS3SdkObjectRoutes(simS3: SimS3): readonly (readonly [string, SimSdkCommandRoute])[];