@kensio/yulin 1.21.2 → 1.21.4

package/dist/service/s3/bucket/lifecycle/sim-s3-lifecycle-transition-instant.js

@@ -0,0 +1,48 @@
+import { simS3StorageClassFrom, } from "../../object/s3-storage-class.js";
+import { simS3LifecycleAfterDays, simS3LifecycleReached, } from "./sim-s3-lifecycle-expiry.js";
+/**
+ * The transition a `Transitions` entry has made by an instant, if it has.
+ *
+ * `Days` counts from when the Object was written and `Date` names the day
+ * itself, the same two forms an `Expiration` takes. A transition naming
+ * neither, or naming no storage class, moves nothing.
+ */
+export function simS3ReachedTransitionOf(transition, writtenAt, now) {
+    return reached(transitionInstant(transition, writtenAt), transition.StorageClass, now);
+}
+/**
+ * The transition a `NoncurrentVersionTransitions` entry has made by an
+ * instant, counted from when the version stopped being the current one.
+ *
+ * A version that is still current has no such instant, as it has none for a
+ * `NoncurrentVersionExpiration`. `NewerNoncurrentVersions` holds back the most
+ * recent noncurrent versions as it does for an expiry, so a rule keeping two
+ * reaches the third and everything older.
+ */
+export function simS3ReachedNoncurrentTransitionOf(transition, version, now) {
+    const { noncurrentSince } = version;
+    if (noncurrentSince === undefined ||
+        transition.NoncurrentDays === undefined ||
+        version.newerVersionsAhead < (transition.NewerNoncurrentVersions ?? 0)) {
+        return undefined;
+    }
+    return reached(simS3LifecycleAfterDays(noncurrentSince, transition.NoncurrentDays), transition.StorageClass, now);
+}
+function transitionInstant(transition, writtenAt) {
+    if (transition.Days !== undefined) {
+        return simS3LifecycleAfterDays(writtenAt, transition.Days);
+    }
+    if (transition.Date !== undefined) {
+        return new Date(transition.Date);
+    }
+    return undefined;
+}
+function reached(at, storageClass, now) {
+    const target = simS3StorageClassFrom(storageClass, "a lifecycle transition");
+    if (at === undefined || target === undefined) {
+        return undefined;
+    }
+    return simS3LifecycleReached(at, now)
+        ? { storageClass: target, at }
+        : undefined;
+}

package/dist/service/s3/bucket/lifecycle/sim-s3-lifecycle-transition.d.ts

@@ -0,0 +1,16 @@
+import type { SimS3LifecycleRule } from "../../command/put-bucket-lifecycle-configuration/put-bucket-lifecycle-configuration.command.js";
+import type { SimS3StorageClass } from "../../object/s3-storage-class.js";
+import type { SimS3LifecycleNoncurrentVersion, SimS3LifecycleObject } from "./sim-s3-lifecycle-subject.js";
+/**
+ * The class the rules have transitioned an Object into by an instant.
+ *
+ * Every rule selecting the Object contributes the transitions it has reached,
+ * because real S3 applies the whole configuration to a key rather than the
+ * first rule that matches it.
+ */
+export declare function simS3TransitionedObjectClass(rules: readonly SimS3LifecycleRule[], object: SimS3LifecycleObject, now: Date): SimS3StorageClass | undefined;
+/**
+ * The class the rules have transitioned a noncurrent version into by an
+ * instant.
+ */
+export declare function simS3TransitionedVersionClass(rules: readonly SimS3LifecycleRule[], version: SimS3LifecycleNoncurrentVersion, now: Date): SimS3StorageClass | undefined;

package/dist/service/s3/bucket/lifecycle/sim-s3-lifecycle-transition.js

@@ -0,0 +1,44 @@
+import { simS3ReachedNoncurrentTransitionOf, simS3ReachedTransitionOf, } from "./sim-s3-lifecycle-transition-instant.js";
+import { simS3LifecycleRuleSelects } from "./sim-s3-lifecycle-selection.js";
+/**
+ * The class the rules have transitioned an Object into by an instant.
+ *
+ * Every rule selecting the Object contributes the transitions it has reached,
+ * because real S3 applies the whole configuration to a key rather than the
+ * first rule that matches it.
+ */
+export function simS3TransitionedObjectClass(rules, object, now) {
+    return latestReached(rules
+        .filter((rule) => simS3LifecycleRuleSelects(rule, object))
+        .flatMap((rule) => reachedTransitions(rule.Transitions, (transition) => simS3ReachedTransitionOf(transition, object.lastModified, now))));
+}
+/**
+ * The class the rules have transitioned a noncurrent version into by an
+ * instant.
+ */
+export function simS3TransitionedVersionClass(rules, version, now) {
+    return latestReached(rules
+        .filter((rule) => simS3LifecycleRuleSelects(rule, version))
+        .flatMap((rule) => reachedTransitions(rule.NoncurrentVersionTransitions, (transition) => simS3ReachedNoncurrentTransitionOf(transition, version, now))));
+}
+/**
+ * The transitions among a rule's that have been reached.
+ */
+function reachedTransitions(transitions, reach) {
+    return (transitions ?? [])
+        .map((transition) => reach(transition))
+        .filter((transition) => transition !== undefined);
+}
+/**
+ * The class an Object is in once every transition that has been reached has
+ * been applied, or nothing where none has.
+ *
+ * The latest one wins. Two reached at the same instant are settled by the
+ * order the rules list them in, so the last transition a configuration states
+ * is where an Object past all of them ends up.
+ */
+function latestReached(transitions) {
+    return transitions
+        .toSorted((one, other) => one.at.getTime() - other.at.getTime())
+        .at(-1)?.storageClass;
+}

package/dist/service/s3/bucket/lifecycle/sim-s3-noncurrent-sweep.d.ts

@@ -41,5 +41,13 @@ export declare class SimS3NoncurrentSweep {
      * marker was the only thing left holding the key there.
      */
     private sweepDeleteMarker;
+    /**
+     * Move a surviving noncurrent version into the class the rules have
+     * transitioned it to.
+     *
+     * The current version and a delete marker are left alone. Neither is
+     * something a `NoncurrentVersionTransitions` rule reaches.
+     */
+    private transition;
     private expires;
 }

package/dist/service/s3/bucket/lifecycle/sim-s3-noncurrent-sweep.js

@@ -1,3 +1,4 @@
+import { simS3TransitionedVersionClass } from "./sim-s3-lifecycle-transition.js";
 /**
  * One pass over what a Bucket's rules have expired in its version history.
  *
@@ -45,6 +46,7 @@ export class SimS3NoncurrentSweep {
         for (const [index, version] of held.entries()) {
             if (index === 0 || !this.expires(version, index - 1)) {
                 kept.push(version);
+                this.transition(version, index - 1);
                 continue;
             }
             versions.removeExpired(version.key, version.versionId);
@@ -66,12 +68,37 @@ export class SimS3NoncurrentSweep {
             versions.removeExpired(marker.key, marker.versionId);
         }
     }
+    /**
+     * Move a surviving noncurrent version into the class the rules have
+     * transitioned it to.
+     *
+     * The current version and a delete marker are left alone. Neither is
+     * something a `NoncurrentVersionTransitions` rule reaches.
+     */
+    transition(version, ahead) {
+        if (ahead < 0 || version.isDeleteMarker) {
+            return;
+        }
+        const storageClass = simS3TransitionedVersionClass(this.lifecycle.enabledRules, {
+            key: version.key,
+            size: version.object.body.length,
+            noncurrentSince: version.noncurrentSince,
+            newerVersionsAhead: ahead,
+            tags: version.object.tags,
+        }, this.now);
+        if (storageClass !== undefined) {
+            version.transitionTo(storageClass);
+        }
+    }
     expires(version, ahead) {
         return this.lifecycle.expiresNoncurrent({
             key: version.key,
             size: version.isDeleteMarker ? 0 : version.object.body.length,
             noncurrentSince: version.noncurrentSince,
             newerVersionsAhead: ahead,
+            // A delete marker holds no Object, so it carries no tags and a rule
+            // filtering on one leaves it alone.
+            tags: version.isDeleteMarker ? undefined : version.object.tags,
         }, this.now);
     }
 }

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

@@ -5,7 +5,7 @@
  * has many more, and the ones it has that this simulator cannot produce are
  * refused by name rather than accepted and never delivered.
  */
-export declare const SIM_S3_NOTIFICATION_EVENTS: readonly ["s3:ObjectCreated:Put", "s3:ObjectCreated:Copy", "s3:ObjectCreated:CompleteMultipartUpload", "s3:ObjectRemoved:Delete", "s3:ObjectRemoved:DeleteMarkerCreated"];
+export declare const SIM_S3_NOTIFICATION_EVENTS: readonly ["s3:ObjectCreated:Put", "s3:ObjectCreated:Copy", "s3:ObjectCreated:CompleteMultipartUpload", "s3:ObjectRemoved:Delete", "s3:ObjectRemoved:DeleteMarkerCreated", "s3:ObjectTagging:Put", "s3:ObjectTagging:Delete"];
 export type SimS3NotificationEvent = (typeof SIM_S3_NOTIFICATION_EVENTS)[number];
 /**
  * The concrete events a configured event type covers.

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

@@ -13,6 +13,8 @@ export const SIM_S3_NOTIFICATION_EVENTS = [
     "s3:ObjectCreated:CompleteMultipartUpload",
     "s3:ObjectRemoved:Delete",
     "s3:ObjectRemoved:DeleteMarkerCreated",
+    "s3:ObjectTagging:Put",
+    "s3:ObjectTagging:Delete",
 ];
 /**
  * What each configurable event type expands to.
@@ -50,6 +52,9 @@ const eventExpansions = new Map([
         "s3:ObjectRemoved:DeleteMarkerCreated",
         ["s3:ObjectRemoved:DeleteMarkerCreated"],
     ],
+    ["s3:ObjectTagging:*", ["s3:ObjectTagging:Put", "s3:ObjectTagging:Delete"]],
+    ["s3:ObjectTagging:Put", ["s3:ObjectTagging:Put"]],
+    ["s3:ObjectTagging:Delete", ["s3:ObjectTagging:Delete"]],
 ]);
 /**
  * The concrete events a configured event type covers.

package/dist/service/s3/bucket/notification/sim-s3-unsimulated-notification-events.js

@@ -21,9 +21,6 @@ export const SIM_S3_UNSIMULATED_NOTIFICATION_EVENTS = new Set([
     "s3:ObjectRestore:Completed",
     "s3:ObjectRestore:Delete",
     "s3:ObjectRestore:Post",
-    "s3:ObjectTagging:*",
-    "s3:ObjectTagging:Delete",
-    "s3:ObjectTagging:Put",
     "s3:ReducedRedundancyLostObject",
     "s3:Replication:*",
     "s3:Replication:OperationFailedReplication",

package/dist/service/s3/bucket/sim-s3-bucket-access.d.ts

@@ -59,6 +59,9 @@ export declare class SimS3BucketAccess {
      * cached. A deployment into the same Bucket has already said it, so the mount
      * inherits what the Bucket was told, and `systemMetadata` is where it
      * declares the rest or answers differently.
+     *
+     * The Bucket serves and accepts writes but refuses a delete, since the files
+     * are the user's own. `allowDelete` is how a mount asks for one.
      */
     mountFilesystem(bucketName: SimS3BucketName | string, directoryPath: string, options?: SimS3MountFilesystemOptions): void;
     /**

package/dist/service/s3/bucket/sim-s3-bucket-access.js

@@ -1,5 +1,5 @@
 import { assertDefined } from "../../../util/type-guard/defined.js";
-import { FilesystemS3BucketStorage } from "../storage/filesystem/s3-filesystem-storage.js";
+import { filesystemS3MountStorage } from "../storage/filesystem/s3-filesystem-deleting-storage.js";
 import { simS3BucketUrl, simS3ServiceUrl } from "./sim-s3-endpoint-url.js";
 import { SimS3DeclaredSystemMetadata } from "../object/s3-declared-system-metadata.js";
 import { SimS3MountWatches } from "../mount/sim-s3-mount-watches.js";
@@ -73,6 +73,9 @@ export class SimS3BucketAccess {
      * cached. A deployment into the same Bucket has already said it, so the mount
      * inherits what the Bucket was told, and `systemMetadata` is where it
      * declares the rest or answers differently.
+     *
+     * The Bucket serves and accepts writes but refuses a delete, since the files
+     * are the user's own. `allowDelete` is how a mount asks for one.
      */
     mountFilesystem(bucketName, directoryPath, options = {}) {
         const bucket = this.required(bucketName);
@@ -80,11 +83,12 @@ export class SimS3BucketAccess {
             inherited: bucket.getDeclaredSystemMetadata(),
             declarations: options.systemMetadata,
         });
-        bucket.configureSimStorage(new FilesystemS3BucketStorage({
+        bucket.configureSimStorage(filesystemS3MountStorage({
             directoryPath,
             ...(options.additionalFileExtensions !== undefined && {
                 additionalFileExtensions: options.additionalFileExtensions,
             }),
+            allowDelete: options.allowDelete,
             systemMetadata,
         }));
         this.mountWatches.register(bucketName, directoryPath, options);

package/dist/service/s3/bucket/sim-s3-bucket-configuration.d.ts

@@ -0,0 +1,84 @@
+import type { SimIamPolicyDocument } from "../../iam/policy/sim-iam-policy.js";
+import { SimS3BucketEncryption } from "./encryption/sim-s3-bucket-encryption.js";
+import { SimS3NotificationConfiguration } from "./notification/sim-s3-notification-configuration.js";
+import { SimS3PublicAccessBlock } from "./public-access/sim-s3-public-access-block.js";
+import type { SimS3BucketProperties } from "./sim-s3-bucket-properties.js";
+import { SimS3BucketWebsite } from "./website/sim-s3-bucket-website.js";
+/**
+ * How one simulated S3 Bucket is configured.
+ *
+ * These are the five configurations a Bucket holds one of rather than a list
+ * of, and each is replaced whole by the request that sets it. None of them says
+ * anything about what the Bucket stores, which is why they sit apart from the
+ * Objects, the versions and the uploads.
+ *
+ * `SimS3Bucket` extends this, so a caller reaches all of them on the Bucket
+ * itself. The lifecycle configuration is the exception and stays with the
+ * Objects, because every read of one applies it.
+ */
+export declare abstract class SimS3BucketConfiguration {
+    private website;
+    private policy;
+    private publicAccessBlock;
+    private notifications;
+    private encryption;
+    protected constructor(properties: SimS3BucketProperties);
+    /**
+     * Configure static website hosting for this simulated S3 Bucket.
+     */
+    configureWebsite(website: SimS3BucketWebsite): void;
+    /**
+     * Get static website configuration for this simulated S3 Bucket.
+     */
+    getWebsite(): SimS3BucketWebsite;
+    /**
+     * Configure the Bucket resource policy.
+     */
+    configurePolicy(policy: SimIamPolicyDocument): void;
+    /**
+     * Get the Bucket resource policy.
+     */
+    getPolicy(): SimIamPolicyDocument | undefined;
+    /**
+     * Remove the Bucket resource policy.
+     *
+     * Real S3 DeleteBucketPolicy is idempotent, so this reports nothing about
+     * whether there was a policy to remove.
+     */
+    deletePolicy(): void;
+    /**
+     * Replace this Bucket's Block Public Access settings.
+     */
+    configurePublicAccessBlock(publicAccessBlock: SimS3PublicAccessBlock): void;
+    /**
+     * Get this Bucket's Block Public Access settings.
+     */
+    getPublicAccessBlock(): SimS3PublicAccessBlock;
+    /**
+     * Remove this Bucket's Block Public Access settings.
+     *
+     * Removing the configuration returns the Bucket to the all-enabled state a
+     * new Bucket starts in, rather than leaving it unprotected.
+     */
+    deletePublicAccessBlock(): void;
+    /**
+     * Replace this Bucket's event notification configuration.
+     *
+     * Real S3 holds one configuration per Bucket rather than a list of them, so
+     * this replaces what was there instead of adding to it.
+     */
+    configureNotifications(notifications: SimS3NotificationConfiguration): void;
+    /** Get this Bucket's event notification configuration. */
+    getNotifications(): SimS3NotificationConfiguration;
+    /** Replace this Bucket's default encryption configuration. */
+    configureEncryption(encryption: SimS3BucketEncryption): void;
+    /** Get this Bucket's default encryption configuration. */
+    getEncryption(): SimS3BucketEncryption;
+    /**
+     * Put this Bucket back to the encryption every Bucket has.
+     *
+     * Real S3 DeleteBucketEncryption leaves the Bucket SSE-S3 encrypted rather
+     * than unencrypted, because there is no such thing as an unencrypted Bucket.
+     */
+    deleteEncryption(): void;
+}

package/dist/service/s3/bucket/sim-s3-bucket-configuration.js

@@ -0,0 +1,115 @@
+import { SimS3BucketEncryption } from "./encryption/sim-s3-bucket-encryption.js";
+import { SimS3NotificationConfiguration } from "./notification/sim-s3-notification-configuration.js";
+import { SimS3PublicAccessBlock } from "./public-access/sim-s3-public-access-block.js";
+import { SimS3BucketWebsite } from "./website/sim-s3-bucket-website.js";
+/**
+ * How one simulated S3 Bucket is configured.
+ *
+ * These are the five configurations a Bucket holds one of rather than a list
+ * of, and each is replaced whole by the request that sets it. None of them says
+ * anything about what the Bucket stores, which is why they sit apart from the
+ * Objects, the versions and the uploads.
+ *
+ * `SimS3Bucket` extends this, so a caller reaches all of them on the Bucket
+ * itself. The lifecycle configuration is the exception and stays with the
+ * Objects, because every read of one applies it.
+ */
+export class SimS3BucketConfiguration {
+    website;
+    policy;
+    publicAccessBlock;
+    notifications;
+    encryption;
+    constructor(properties) {
+        const { website = new SimS3BucketWebsite(), publicAccessBlock = SimS3PublicAccessBlock.blockingAll(), notifications = SimS3NotificationConfiguration.empty(), encryption = SimS3BucketEncryption.default(), } = properties;
+        this.website = website;
+        this.policy = properties.policy;
+        this.publicAccessBlock = publicAccessBlock;
+        this.notifications = notifications;
+        this.encryption = encryption;
+    }
+    /**
+     * Configure static website hosting for this simulated S3 Bucket.
+     */
+    configureWebsite(website) {
+        this.website = website;
+    }
+    /**
+     * Get static website configuration for this simulated S3 Bucket.
+     */
+    getWebsite() {
+        return this.website;
+    }
+    /**
+     * Configure the Bucket resource policy.
+     */
+    configurePolicy(policy) {
+        this.policy = policy;
+    }
+    /**
+     * Get the Bucket resource policy.
+     */
+    getPolicy() {
+        return this.policy;
+    }
+    /**
+     * Remove the Bucket resource policy.
+     *
+     * Real S3 DeleteBucketPolicy is idempotent, so this reports nothing about
+     * whether there was a policy to remove.
+     */
+    deletePolicy() {
+        this.policy = undefined;
+    }
+    /**
+     * Replace this Bucket's Block Public Access settings.
+     */
+    configurePublicAccessBlock(publicAccessBlock) {
+        this.publicAccessBlock = publicAccessBlock;
+    }
+    /**
+     * Get this Bucket's Block Public Access settings.
+     */
+    getPublicAccessBlock() {
+        return this.publicAccessBlock;
+    }
+    /**
+     * Remove this Bucket's Block Public Access settings.
+     *
+     * Removing the configuration returns the Bucket to the all-enabled state a
+     * new Bucket starts in, rather than leaving it unprotected.
+     */
+    deletePublicAccessBlock() {
+        this.publicAccessBlock = SimS3PublicAccessBlock.blockingAll();
+    }
+    /**
+     * Replace this Bucket's event notification configuration.
+     *
+     * Real S3 holds one configuration per Bucket rather than a list of them, so
+     * this replaces what was there instead of adding to it.
+     */
+    configureNotifications(notifications) {
+        this.notifications = notifications;
+    }
+    /** Get this Bucket's event notification configuration. */
+    getNotifications() {
+        return this.notifications;
+    }
+    /** Replace this Bucket's default encryption configuration. */
+    configureEncryption(encryption) {
+        this.encryption = encryption;
+    }
+    /** Get this Bucket's default encryption configuration. */
+    getEncryption() {
+        return this.encryption;
+    }
+    /**
+     * Put this Bucket back to the encryption every Bucket has.
+     *
+     * Real S3 DeleteBucketEncryption leaves the Bucket SSE-S3 encrypted rather
+     * than unencrypted, because there is no such thing as an unencrypted Bucket.
+     */
+    deleteEncryption() {
+        this.encryption = SimS3BucketEncryption.default();
+    }
+}

package/dist/service/s3/bucket/sim-s3-bucket-objects.d.ts

@@ -5,6 +5,7 @@ import { SimS3MultipartUploads } from "../upload/sim-s3-multipart-uploads.js";
 import { SimS3BucketObjectLock } from "./lock/sim-s3-bucket-object-lock.js";
 import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-configuration.js";
 import { SimS3ObjectDeletion } from "./sim-s3-object-deletion.js";
+import { SimS3TaggableObject } from "./tagging/sim-s3-taggable-object.js";
 import type { SimS3BucketVersioning } from "./versioning/sim-s3-bucket-versioning.js";
 import { SimS3BucketVersions } from "./versioning/sim-s3-bucket-versions.js";
 import type { SimS3ObjectVersion } from "./versioning/sim-s3-object-version.js";
@@ -64,6 +65,15 @@ export declare class SimS3BucketObjects {
      * Lock is holding never gets that far.
      */
     deleteVersion(key: string, versionId: string, bypassGovernance?: boolean): Promise<SimS3ObjectVersion | undefined>;
+    /**
+     * The Object a tagging request names, ready to be read or retagged.
+     *
+     * A request naming a version acts on that version, and one naming none acts
+     * on whatever a plain read of the key answers with. The read happens either
+     * way, because it is what applies the Bucket's rules, and a request naming a
+     * version has no more effect on the Bucket than any other read of it.
+     */
+    taggable(key: string, versionId: string | undefined): Promise<SimS3TaggableObject>;
     /**
      * The versions this Bucket keeps, with whatever the rules have expired gone.
      *

package/dist/service/s3/bucket/sim-s3-bucket-objects.js

@@ -4,6 +4,7 @@ import { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-config
 import { SimS3NoncurrentSweep } from "./lifecycle/sim-s3-noncurrent-sweep.js";
 import { SimS3LifecycleSweep } from "./lifecycle/sim-s3-lifecycle-sweep.js";
 import { SimS3ObjectDeletion } from "./sim-s3-object-deletion.js";
+import { SimS3TaggableObject } from "./tagging/sim-s3-taggable-object.js";
 import { SimS3BucketVersions } from "./versioning/sim-s3-bucket-versions.js";
 /**
  * What one simulated S3 Bucket stores, and what time does to it.
@@ -80,6 +81,23 @@ export class SimS3BucketObjects {
         this.objectLock.assertDeletable(this.versions.find(key, versionId), this.clock.now(), bypassGovernance);
         return await this.versions.deleteVersion(this.storage, key, versionId);
     }
+    /**
+     * The Object a tagging request names, ready to be read or retagged.
+     *
+     * A request naming a version acts on that version, and one naming none acts
+     * on whatever a plain read of the key answers with. The read happens either
+     * way, because it is what applies the Bucket's rules, and a request naming a
+     * version has no more effect on the Bucket than any other read of it.
+     */
+    async taggable(key, versionId) {
+        return SimS3TaggableObject.named({
+            storage: this.storage,
+            versions: this.sweptVersions(),
+            key,
+            versionId,
+            stored: await this.get(key),
+        });
+    }
     /**
      * The versions this Bucket keeps, with whatever the rules have expired gone.
      *

package/dist/service/s3/bucket/sim-s3-bucket-properties.d.ts

@@ -0,0 +1,41 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimIamPolicyDocument } from "../../iam/policy/sim-iam-policy.js";
+import type { SimS3BucketStorage } from "../storage/s3-bucket-storage.js";
+import type { SimS3BucketEncryption } from "./encryption/sim-s3-bucket-encryption.js";
+import type { SimS3LifecycleConfiguration } from "./lifecycle/sim-s3-lifecycle-configuration.js";
+import type { SimS3NotificationConfiguration } from "./notification/sim-s3-notification-configuration.js";
+import type { SimS3PublicAccessBlock } from "./public-access/sim-s3-public-access-block.js";
+import type { SimS3BucketName } from "./sim-s3-bucket.js";
+import type { SimS3BucketWebsite } from "./website/sim-s3-bucket-website.js";
+/**
+ * What a simulated S3 Bucket is made of.
+ *
+ * Every one of these has a default, apart from the name. A Bucket made by
+ * CreateBucket states only its name and its scope, and the configuration
+ * properties are what a Bucket built directly in a test starts out with.
+ */
+export interface SimS3BucketProperties {
+    readonly bucketName: SimS3BucketName | string;
+    readonly accountRegionScope?: SimAwsAccountRegionScope;
+    readonly storage?: SimS3BucketStorage;
+    readonly website?: SimS3BucketWebsite;
+    readonly policy?: SimIamPolicyDocument | undefined;
+    readonly publicAccessBlock?: SimS3PublicAccessBlock;
+    readonly notifications?: SimS3NotificationConfiguration;
+    readonly lifecycle?: SimS3LifecycleConfiguration;
+    readonly encryption?: SimS3BucketEncryption;
+    /**
+     * The simulation's sense of time, which is what a lifecycle rule is measured
+     * against. A Bucket made outside a simulated environment has none to be
+     * given, and runs on the host clock.
+     */
+    readonly clock?: SimClock;
+    /**
+     * When the Bucket came into being, in simulated time.
+     *
+     * Real S3 reports this on every Bucket a listing returns, and the `aws` CLI
+     * reads it from each entry, so a Bucket without one cannot be listed.
+     */
+    readonly creationDate?: Date;
+}

package/dist/service/s3/bucket/sim-s3-bucket-properties.js

@@ -0,0 +1 @@
+export {};