@kensio/yulin 1.20.17 → 1.21.1

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

@@ -0,0 +1,102 @@
+import { SimS3InvalidRequest } from "../../error/sim-s3.error.js";
+import { SimS3ObjectRetention } from "./sim-s3-object-retention.js";
+import { simS3RetentionMode } from "./sim-s3-default-retention.js";
+const millisecondsPerDay = 86_400_000;
+const daysPerYear = 365;
+/**
+ * The longest default retention real S3 takes, which is a hundred years.
+ *
+ * An unbounded one would compute a `RetainUntilDate` past the range a
+ * JavaScript Date holds, and a version retained until an instant that reads
+ * back as `NaN` is a version nothing is holding at all.
+ */
+const maximumRetentionDays = 100 * daysPerYear;
+/** The one value `ObjectLockEnabled` takes. Real S3 has no way to turn it off. */
+export const simS3ObjectLockEnabled = "Enabled";
+/**
+ * How one simulated S3 Bucket is locked, and for how long by default.
+ *
+ * A Bucket either has Object Lock turned on or has never had it. Real S3 has
+ * no request that turns it off again, which is what lets a reader's history be
+ * promised rather than merely configured.
+ *
+ * The default retention is optional. A Bucket with Object Lock on and no
+ * default locks nothing on its own, and every version it holds is retained
+ * only by the requests that name it. A Bucket with one retains every version
+ * written after it, counted from the write.
+ */
+export class SimS3ObjectLockConfiguration {
+    defaults;
+    constructor(defaults) {
+        this.defaults = defaults;
+    }
+    /**
+     * Read a configuration a request is setting, refusing one real S3 refuses.
+     */
+    static parse(input) {
+        if (input.ObjectLockEnabled !== simS3ObjectLockEnabled) {
+            throw new SimS3InvalidRequest(`ObjectLockEnabled has to be ${simS3ObjectLockEnabled}`);
+        }
+        const declared = input.Rule?.DefaultRetention;
+        if (declared === undefined) {
+            return new SimS3ObjectLockConfiguration();
+        }
+        return new SimS3ObjectLockConfiguration({
+            mode: simS3RetentionMode(declared.Mode),
+            days: simS3DefaultRetentionDays(declared),
+        });
+    }
+    /**
+     * The retention a version written at an instant is given.
+     *
+     * Real S3 counts a default retention from the write rather than from the
+     * configuration, so two versions of one key written a day apart are retained
+     * until two different instants.
+     */
+    retentionAt(instant) {
+        const defaults = this.defaults;
+        if (defaults === undefined) {
+            return undefined;
+        }
+        return new SimS3ObjectRetention({
+            mode: defaults.mode,
+            retainUntil: new Date(instant.getTime() + defaults.days * millisecondsPerDay),
+        });
+    }
+    /** What GetObjectLockConfiguration answers with. */
+    get reported() {
+        const defaults = this.defaults;
+        return {
+            ObjectLockEnabled: simS3ObjectLockEnabled,
+            ...(defaults !== undefined && {
+                Rule: {
+                    DefaultRetention: { Mode: defaults.mode, Days: defaults.days },
+                },
+            }),
+        };
+    }
+}
+/**
+ * The length of a default retention, in days.
+ *
+ * Real S3 takes it as either `Days` or `Years` and refuses both together. A
+ * year is 365 days here, which is what S3 documents its own arithmetic as.
+ */
+function simS3DefaultRetentionDays(declared) {
+    const { Days, Years } = declared;
+    if ((Days === undefined) === (Years === undefined)) {
+        throw new SimS3InvalidRequest("Object Lock DefaultRetention requires either Days or Years, and " +
+            "refuses both together");
+    }
+    const period = Days ?? Years;
+    if (period === undefined || period < 1 || !Number.isSafeInteger(period)) {
+        throw new SimS3InvalidRequest(`Object Lock DefaultRetention period ${String(period)} has to be a ` +
+            `whole number of at least 1`);
+    }
+    const days = Days === undefined ? period * daysPerYear : period;
+    if (days > maximumRetentionDays) {
+        throw new SimS3InvalidRequest(`Object Lock DefaultRetention period ${String(period)} is longer than ` +
+            `the hundred years real S3 retains a version for`);
+    }
+    return days;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * What a read of an Object says about the Object Lock holding it.
+ *
+ * `GetObject` and `HeadObject` both report these, and a version nothing is
+ * holding leaves all three out rather than reporting them empty.
+ */
+export interface SimS3ObjectLockOutput {
+    /** The mode of the retention period on the version, if it has one. */
+    readonly ObjectLockMode?: string;
+    /** When that period lapses. */
+    readonly ObjectLockRetainUntilDate?: Date;
+    /** `ON` while a legal hold is on the version, and absent otherwise. */
+    readonly ObjectLockLegalHoldStatus?: string;
+}

package/dist/service/s3/bucket/lock/sim-s3-object-lock-output.js

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

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

@@ -0,0 +1,62 @@
+import { type SimS3ObjectRetention } from "./sim-s3-object-retention.js";
+/** The two values `LegalHold.Status` takes. */
+export declare const simS3LegalHoldOn = "ON";
+export declare const simS3LegalHoldOff = "OFF";
+/**
+ * Structural shape of an S3 ObjectLockLegalHold.
+ */
+export interface SimS3LegalHoldInput {
+    readonly Status?: string | undefined;
+}
+/**
+ * What Object Lock holds against one version of one Object.
+ *
+ * A retention period and a legal hold are configured independently and either
+ * one on its own refuses a delete. The difference is that a retention lapses
+ * when simulated time passes it and a legal hold has no expiry to wait out, so
+ * the only way past one is to take it off.
+ *
+ * This is mutable, unlike the version holding it. Real S3 changes both through
+ * requests of their own against a version that is already there, and a version
+ * whose retention could not change would have no PutObjectRetention.
+ */
+export declare class SimS3ObjectLock {
+    private retention;
+    private legalHold;
+    /**
+     * Put a retention on this version, refusing one real S3 refuses.
+     *
+     * Object Lock is a guarantee rather than a setting, so the ways out of one
+     * are the point. A compliance period can be extended in the same mode, by
+     * anyone, and that is all that can be done to it. Shortening one would end
+     * the guarantee early, and turning one into a governance period would hand
+     * it to the first caller holding the bypass permission, so both are refused
+     * whoever asks and whatever they bypass.
+     *
+     * A governance period can be shortened, or turned into a compliance one, by
+     * a caller who names `BypassGovernanceRetention`, and the caller's
+     * permission to do that is checked before this is reached.
+     */
+    applyRetention(retention: SimS3ObjectRetention, bypassed: boolean): void;
+    /**
+     * Turn the legal hold on this version on or off.
+     */
+    applyLegalHold(input: SimS3LegalHoldInput): void;
+    /**
+     * Set the retention a Bucket's default puts on a new version.
+     *
+     * Nothing is checked, because a version this is reached for has just been
+     * written and carries no retention to be shortening.
+     */
+    setDefaultRetention(retention: SimS3ObjectRetention): void;
+    /**
+     * Whether Object Lock refuses to let this version be deleted.
+     *
+     * A legal hold refuses whatever the caller says, since there is no bypass
+     * for one. A retention that has lapsed refuses nothing, which is what makes
+     * advancing the clock the way past a governance or a compliance period.
+     */
+    refusesDeleteAt(instant: Date, bypassed: boolean): string | undefined;
+    /** What GetObject and HeadObject report about the version. */
+    get reported(): Record<string, string | Date>;
+}

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

@@ -0,0 +1,100 @@
+import { SimS3InvalidRequest } from "../../error/sim-s3.error.js";
+import { simS3ComplianceMode, simS3GovernanceMode, } from "./sim-s3-object-retention.js";
+/** The two values `LegalHold.Status` takes. */
+export const simS3LegalHoldOn = "ON";
+export const simS3LegalHoldOff = "OFF";
+/** The two statuses, as a refusal names them. */
+const legalHoldStatuses = `${simS3LegalHoldOn} or ${simS3LegalHoldOff}`;
+/**
+ * What Object Lock holds against one version of one Object.
+ *
+ * A retention period and a legal hold are configured independently and either
+ * one on its own refuses a delete. The difference is that a retention lapses
+ * when simulated time passes it and a legal hold has no expiry to wait out, so
+ * the only way past one is to take it off.
+ *
+ * This is mutable, unlike the version holding it. Real S3 changes both through
+ * requests of their own against a version that is already there, and a version
+ * whose retention could not change would have no PutObjectRetention.
+ */
+export class SimS3ObjectLock {
+    retention;
+    legalHold = false;
+    /**
+     * Put a retention on this version, refusing one real S3 refuses.
+     *
+     * Object Lock is a guarantee rather than a setting, so the ways out of one
+     * are the point. A compliance period can be extended in the same mode, by
+     * anyone, and that is all that can be done to it. Shortening one would end
+     * the guarantee early, and turning one into a governance period would hand
+     * it to the first caller holding the bypass permission, so both are refused
+     * whoever asks and whatever they bypass.
+     *
+     * A governance period can be shortened, or turned into a compliance one, by
+     * a caller who names `BypassGovernanceRetention`, and the caller's
+     * permission to do that is checked before this is reached.
+     */
+    applyRetention(retention, bypassed) {
+        const held = this.retention;
+        if (held === undefined) {
+            this.retention = retention;
+            return;
+        }
+        const extending = retention.mode === held.mode && retention.isAtLeast(held);
+        if (extending || (bypassed && held.mode === simS3GovernanceMode)) {
+            this.retention = retention;
+            return;
+        }
+        throw new SimS3InvalidRequest(held.mode === simS3ComplianceMode
+            ? "A COMPLIANCE retention period can only be extended in the same " +
+                "mode, and never shortened or turned into a GOVERNANCE one"
+            : "Shortening a GOVERNANCE retention period, or changing its mode, " +
+                "requires BypassGovernanceRetention");
+    }
+    /**
+     * Turn the legal hold on this version on or off.
+     */
+    applyLegalHold(input) {
+        if (input.Status !== simS3LegalHoldOn &&
+            input.Status !== simS3LegalHoldOff) {
+            throw new SimS3InvalidRequest(`Object Lock legal hold Status has to be ${legalHoldStatuses}`);
+        }
+        this.legalHold = input.Status === simS3LegalHoldOn;
+    }
+    /**
+     * Set the retention a Bucket's default puts on a new version.
+     *
+     * Nothing is checked, because a version this is reached for has just been
+     * written and carries no retention to be shortening.
+     */
+    setDefaultRetention(retention) {
+        this.retention = retention;
+    }
+    /**
+     * Whether Object Lock refuses to let this version be deleted.
+     *
+     * A legal hold refuses whatever the caller says, since there is no bypass
+     * for one. A retention that has lapsed refuses nothing, which is what makes
+     * advancing the clock the way past a governance or a compliance period.
+     */
+    refusesDeleteAt(instant, bypassed) {
+        if (this.legalHold) {
+            return "it is under a legal hold";
+        }
+        const retention = this.retention;
+        if (retention === undefined || !retention.isActiveAt(instant)) {
+            return undefined;
+        }
+        if (bypassed && retention.mode === simS3GovernanceMode) {
+            return undefined;
+        }
+        return `it is under a ${retention.mode} retention period until ${retention.retainUntilDate.toISOString()}`;
+    }
+    /** What GetObject and HeadObject report about the version. */
+    get reported() {
+        return {
+            ...this.retention?.reported,
+            ...(this.legalHold && { ObjectLockLegalHoldStatus: simS3LegalHoldOn }),
+        };
+    }
+}

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

@@ -0,0 +1,55 @@
+/**
+ * The two modes a retention period can be in.
+ *
+ * Governance is the one an account can get out of, by naming
+ * `BypassGovernanceRetention` while holding `s3:BypassGovernanceRetention`.
+ * Compliance is the one nobody can, including the account root, which is what
+ * makes it worth having.
+ */
+export declare const simS3GovernanceMode = "GOVERNANCE";
+export declare const simS3ComplianceMode = "COMPLIANCE";
+/** The two modes, as a refusal names them. */
+export declare const simS3RetentionModeNames = "GOVERNANCE or COMPLIANCE";
+/**
+ * Structural shape of an S3 ObjectLockRetention.
+ *
+ * Matches the AWS SDK and CloudFormation property shape, so the same object
+ * can come from either.
+ */
+export interface SimS3RetentionInput {
+    readonly Mode?: string | undefined;
+    readonly RetainUntilDate?: Date | string | undefined;
+}
+interface SimS3ObjectRetentionProperties {
+    readonly mode: string;
+    readonly retainUntil: Date;
+}
+/**
+ * How long one version of one Object cannot be deleted for.
+ *
+ * A retention is a mode and an instant, and the instant is compared against
+ * simulated time on every delete. Nothing schedules its expiry: the period
+ * lapses because the clock moved past it, which is how a test watches a
+ * retained version become deletable.
+ */
+export declare class SimS3ObjectRetention {
+    readonly mode: string;
+    private readonly retainUntil;
+    constructor(properties: SimS3ObjectRetentionProperties);
+    /**
+     * Read a retention a request is setting, refusing one real S3 refuses.
+     */
+    static parse(input: SimS3RetentionInput): SimS3ObjectRetention;
+    /** When the period lapses. A copy, because a Date is mutable. */
+    get retainUntilDate(): Date;
+    /** Whether this retention still holds at an instant of simulated time. */
+    isActiveAt(instant: Date): boolean;
+    /** Whether this retention runs at least as long as another. */
+    isAtLeast(other: SimS3ObjectRetention): boolean;
+    /** What GetObject and HeadObject report about the version. */
+    get reported(): {
+        ObjectLockMode: string;
+        ObjectLockRetainUntilDate: Date;
+    };
+}
+export {};

package/dist/service/s3/bucket/lock/sim-s3-object-retention.js

@@ -0,0 +1,82 @@
+import { SimS3InvalidRequest } from "../../error/sim-s3.error.js";
+/**
+ * The two modes a retention period can be in.
+ *
+ * Governance is the one an account can get out of, by naming
+ * `BypassGovernanceRetention` while holding `s3:BypassGovernanceRetention`.
+ * Compliance is the one nobody can, including the account root, which is what
+ * makes it worth having.
+ */
+export const simS3GovernanceMode = "GOVERNANCE";
+export const simS3ComplianceMode = "COMPLIANCE";
+const retentionModes = new Set([
+    simS3GovernanceMode,
+    simS3ComplianceMode,
+]);
+/** The two modes, as a refusal names them. */
+export const simS3RetentionModeNames = `${simS3GovernanceMode} or ${simS3ComplianceMode}`;
+/**
+ * How long one version of one Object cannot be deleted for.
+ *
+ * A retention is a mode and an instant, and the instant is compared against
+ * simulated time on every delete. Nothing schedules its expiry: the period
+ * lapses because the clock moved past it, which is how a test watches a
+ * retained version become deletable.
+ */
+export class SimS3ObjectRetention {
+    mode;
+    retainUntil;
+    constructor(properties) {
+        this.mode = properties.mode;
+        this.retainUntil = new Date(properties.retainUntil);
+    }
+    /**
+     * Read a retention a request is setting, refusing one real S3 refuses.
+     */
+    static parse(input) {
+        const mode = input.Mode;
+        if (mode === undefined || !retentionModes.has(mode)) {
+            throw new SimS3InvalidRequest(`Object Lock retention Mode has to be ${simS3RetentionModeNames}`);
+        }
+        return new SimS3ObjectRetention({
+            mode,
+            retainUntil: retainUntilDate(input.RetainUntilDate),
+        });
+    }
+    /** When the period lapses. A copy, because a Date is mutable. */
+    get retainUntilDate() {
+        return new Date(this.retainUntil);
+    }
+    /** Whether this retention still holds at an instant of simulated time. */
+    isActiveAt(instant) {
+        return instant.getTime() < this.retainUntil.getTime();
+    }
+    /** Whether this retention runs at least as long as another. */
+    isAtLeast(other) {
+        return this.retainUntil.getTime() >= other.retainUntil.getTime();
+    }
+    /** What GetObject and HeadObject report about the version. */
+    get reported() {
+        return {
+            ObjectLockMode: this.mode,
+            ObjectLockRetainUntilDate: this.retainUntilDate,
+        };
+    }
+}
+/**
+ * Read the instant a retention runs until.
+ *
+ * The SDK sends a Date and CloudFormation sends the string it was written as,
+ * so both are read. A value that is not a date at all leaves a version looking
+ * retained until an unknowable instant, so it is refused instead.
+ */
+function retainUntilDate(value) {
+    if (value === undefined) {
+        throw new SimS3InvalidRequest("Object Lock retention requires a RetainUntilDate");
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new SimS3InvalidRequest(`Object Lock retention RetainUntilDate ${String(value)} is not a date`);
+    }
+    return parsed;
+}

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"];
+export declare const SIM_S3_NOTIFICATION_EVENTS: readonly ["s3:ObjectCreated:Put", "s3:ObjectCreated:Copy", "s3:ObjectCreated:CompleteMultipartUpload", "s3:ObjectRemoved:Delete", "s3:ObjectRemoved:DeleteMarkerCreated"];
 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

@@ -12,6 +12,7 @@ export const SIM_S3_NOTIFICATION_EVENTS = [
     "s3:ObjectCreated:Copy",
     "s3:ObjectCreated:CompleteMultipartUpload",
     "s3:ObjectRemoved:Delete",
+    "s3:ObjectRemoved:DeleteMarkerCreated",
 ];
 /**
  * What each configurable event type expands to.
@@ -40,8 +41,15 @@ const eventExpansions = new Map([
         "s3:ObjectCreated:CompleteMultipartUpload",
         ["s3:ObjectCreated:CompleteMultipartUpload"],
     ],
-    ["s3:ObjectRemoved:*", ["s3:ObjectRemoved:Delete"]],
+    [
+        "s3:ObjectRemoved:*",
+        ["s3:ObjectRemoved:Delete", "s3:ObjectRemoved:DeleteMarkerCreated"],
+    ],
     ["s3:ObjectRemoved:Delete", ["s3:ObjectRemoved:Delete"]],
+    [
+        "s3:ObjectRemoved:DeleteMarkerCreated",
+        ["s3:ObjectRemoved:DeleteMarkerCreated"],
+    ],
 ]);
 /**
  * The concrete events a configured event type covers.

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

@@ -4,7 +4,7 @@
  * Listed so an unsimulated event type is refused as unsimulated rather than as
  * a typo, which are different problems with different fixes. Everything here
  * either describes an S3 feature the simulator has no model of, such as
- * versioning, replication or lifecycle rules, or a way of creating an Object
+ * replication or storage class transitions, or a way of creating an Object
  * that it has no command for.
  *
  * https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-event-types-and-destinations.html

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

@@ -4,7 +4,7 @@
  * Listed so an unsimulated event type is refused as unsimulated rather than as
  * a typo, which are different problems with different fixes. Everything here
  * either describes an S3 feature the simulator has no model of, such as
- * versioning, replication or lifecycle rules, or a way of creating an Object
+ * replication or storage class transitions, or a way of creating an Object
  * that it has no command for.
  *
  * https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-event-types-and-destinations.html
@@ -17,7 +17,6 @@ export const SIM_S3_UNSIMULATED_NOTIFICATION_EVENTS = new Set([
     "s3:LifecycleTransition",
     "s3:ObjectAcl:Put",
     "s3:ObjectCreated:Post",
-    "s3:ObjectRemoved:DeleteMarkerCreated",
     "s3:ObjectRestore:*",
     "s3:ObjectRestore:Completed",
     "s3:ObjectRestore:Delete",

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

@@ -0,0 +1,114 @@
+import type { SimClock } from "../../../util/clock/sim-clock.js";
+import type { SimS3Object } from "../object/s3-object.js";
+import type { SimS3BucketStorage } from "../storage/s3-bucket-storage.js";
+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 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";
+interface SimS3BucketObjectsProperties {
+    readonly storage: SimS3BucketStorage;
+    readonly lifecycle: SimS3LifecycleConfiguration;
+    readonly clock: SimClock;
+}
+/**
+ * What one simulated S3 Bucket stores, and what time does to it.
+ *
+ * Storage holds the current Object under each key and nothing else. Versions
+ * and multipart uploads sit alongside it because neither is reachable through
+ * a plain read of a key, and lifecycle rules are here because every read is
+ * what applies them. Nothing sweeps a Bucket on a schedule.
+ */
+export declare class SimS3BucketObjects {
+    readonly versions: SimS3BucketVersions;
+    readonly objectLock: SimS3BucketObjectLock;
+    private readonly clock;
+    private readonly uploads;
+    private storage;
+    private lifecycle;
+    constructor(properties: SimS3BucketObjectsProperties);
+    /**
+     * Put an Object into storage, answering the version it was given.
+     *
+     * A Bucket that keeps no versions answers with nothing, which is what tells
+     * a caller there is no `VersionId` to report. A version the Bucket did keep
+     * starts under whatever default retention Object Lock puts on it.
+     */
+    put(object: SimS3Object): Promise<SimS3ObjectVersion | undefined>;
+    /**
+     * Get an Object from storage.
+     *
+     * An Object a lifecycle rule has expired goes on the way past. Every read of
+     * it then finds the key empty.
+     */
+    get(key: string): Promise<SimS3Object | undefined>;
+    /**
+     * List the Objects currently under a prefix.
+     */
+    list(prefix?: string): Promise<SimS3Object[]>;
+    /**
+     * Delete a key, answering what that did to the Bucket.
+     *
+     * A versioned Bucket writes a delete marker and keeps the Object behind it.
+     * Real S3 writes the marker whether or not the key held anything, so a
+     * delete of a key that was never written still leaves one.
+     */
+    delete(key: string): Promise<SimS3ObjectDeletion>;
+    /**
+     * Remove one version permanently, answering the version that went.
+     *
+     * Whatever the removal leaves at the head of the key becomes current, so
+     * deleting a delete marker brings the Object under it back. A version Object
+     * Lock is holding never gets that far.
+     */
+    deleteVersion(key: string, versionId: string, bypassGovernance?: boolean): Promise<SimS3ObjectVersion | undefined>;
+    /**
+     * The versions this Bucket keeps, with whatever the rules have expired gone.
+     *
+     * Every read of the history goes through here, the way every read of an
+     * Object goes through the Object sweep. A noncurrent version and a bare
+     * delete marker are both invisible to storage, so this removes them without
+     * touching it.
+     */
+    sweptVersions(): SimS3BucketVersions;
+    /**
+     * Apply a versioning configuration, giving what is already stored the null
+     * version id where this is the Bucket's first.
+     */
+    configureVersioning(versioning: SimS3BucketVersioning): Promise<void>;
+    /**
+     * The multipart uploads this Bucket has in progress.
+     *
+     * Kept apart from storage because the parts of an unfinished upload are not
+     * Objects. Nothing that lists or reads a Bucket can see them, and only
+     * completing the upload puts anything under a key.
+     */
+    multipartUploads(): SimS3MultipartUploads;
+    /**
+     * Change the storage implementation behind this Bucket.
+     */
+    configureStorage(storage: SimS3BucketStorage): void;
+    /**
+     * Replace this Bucket's lifecycle 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.
+     */
+    configureLifecycle(lifecycle: SimS3LifecycleConfiguration): void;
+    /**
+     * Get this Bucket's lifecycle configuration.
+     */
+    getLifecycle(): SimS3LifecycleConfiguration;
+    /**
+     * Remove this Bucket's lifecycle configuration.
+     *
+     * Real S3 DeleteBucketLifecycle is idempotent, so this reports nothing about
+     * whether there were rules to remove.
+     */
+    deleteLifecycle(): void;
+    /** What this Bucket's rules have expired, as they stand at this moment. */
+    private sweep;
+}
+export {};