terraconstructs 0.0.8

package/lib/aws/storage/bucket.js

@@ -0,0 +1,869 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventType = exports.StorageClass = exports.Bucket = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const provider_time_1 = require("@cdktf/provider-time");
+const _1 = require(".");
+const __1 = require("..");
+const iam = require("../iam");
+const perms = require("./bucket-perms");
+/**
+ * The `Bucket` beacon provides an [AWS S3 Bucket](https://aws.amazon.com/s3/).
+ *
+ * ```ts
+ * new storage.Bucket(stack, "MyWebsite", {
+ *   path: path.join(__dirname, "dist"),
+ * });
+ * ```
+ *
+ * #### Public read access
+ *
+ * Enables `public` read access for all the files in the bucket. Dangerous and
+ * recommended to use edge.Distribution instead.
+ *
+ * Useful for hosting public files directly from S3.
+ *
+ * ```ts
+ * new storage.Bucket("MyBucket", {
+ *   public: true
+ * });
+ * ```
+ *
+ * @resource aws_s3_bucket
+ * @terraconstruct storage.IBucket
+ */
+class Bucket extends __1.AwsConstructBase {
+    get versioned() {
+        return this._versioned;
+    }
+    get bucketOutputs() {
+        return this._outputs;
+    }
+    get outputs() {
+        return this.bucketOutputs;
+    }
+    get bucketName() {
+        return this.resource.bucket;
+    }
+    get bucketArn() {
+        return this.resource.arn;
+    }
+    get hostedZoneId() {
+        return this.resource.hostedZoneId;
+    }
+    get websiteDomainName() {
+        return this.websiteConfig?.websiteDomain;
+    }
+    constructor(scope, name, props = {}) {
+        super(scope, name, props);
+        /** @internal */
+        this.sources = [];
+        this.node.addValidation({
+            validate: () => this.policy?.document.validateForResourcePolicy() ?? [],
+        });
+        const { websiteConfig, corsConfig, cloudfrontAccess } = props;
+        this._isWebsite = false;
+        if (props.bucketName && props.namePrefix) {
+            throw new Error("Cannot specify both 'bucketName' and 'namePrefix'. Use only one.");
+        }
+        let bucketPrefix;
+        if (!props.bucketName) {
+            // Bucket names must be lowercase and between 3 (min) and 63 (max) characters long.
+            bucketPrefix = this.stack.uniqueResourceNamePrefix(this, {
+                prefix: (props.namePrefix ?? this.gridUUID) + "-",
+                lowerCase: true,
+                allowedSpecialCharacters: ".-",
+                maxLength: 63,
+            });
+        }
+        this.resource = new provider_aws_1.s3Bucket.S3Bucket(this, "Resource", {
+            bucket: props.bucketName,
+            forceDestroy: props.forceDestroy,
+            bucketPrefix,
+        });
+        this._versioned = props.versioned ?? false;
+        if (this._versioned) {
+            new provider_aws_1.s3BucketVersioning.S3BucketVersioningA(this, "Versioning", {
+                bucket: this.resource.bucket,
+                versioningConfiguration: {
+                    status: this._versioned ? "Enabled" : "Suspended",
+                },
+            });
+        }
+        this.eventBridgeEnabled = props.eventBridgeEnabled;
+        if (props.sources) {
+            if (typeof props.sources === "string") {
+                this.addSource({ path: props.sources });
+            }
+            else if (Array.isArray(props.sources)) {
+                for (const sourceProps of props.sources) {
+                    if (typeof sourceProps === "string") {
+                        this.addSource({ path: sourceProps });
+                    }
+                    else {
+                        this.addSource(sourceProps);
+                    }
+                }
+            }
+        }
+        if (props.lifecycleRules) {
+            new provider_aws_1.s3BucketLifecycleConfiguration.S3BucketLifecycleConfiguration(this, "LifeCycleConfig", {
+                bucket: this.resource.bucket,
+                rule: props.lifecycleRules.map((rule) => ({
+                    ...rule,
+                    status: rule.enabled ? "Enabled" : "Disabled",
+                })),
+            });
+        }
+        // Enforce AWS Foundational Security Best Practice
+        if (props.enforceSSL) {
+            this.enforceSSLStatement();
+            this.minimumTLSVersionStatement(props.minimumTLSVersion);
+        }
+        else if (props.minimumTLSVersion) {
+            throw new Error("'enforceSSL' must be enabled for 'minimumTLSVersion' to be applied");
+        }
+        if (websiteConfig && websiteConfig.enabled) {
+            this._isWebsite = true;
+            this.websiteConfig =
+                new provider_aws_1.s3BucketWebsiteConfiguration.S3BucketWebsiteConfiguration(this, "WebsiteConfig", {
+                    bucket: this.resource.bucket,
+                    ...websiteConfig,
+                    indexDocument: websiteConfig?.indexDocument
+                        ? {
+                            suffix: websiteConfig.indexDocument,
+                        }
+                        : {
+                            suffix: "index.html",
+                        },
+                });
+        }
+        this.public = props.public ?? false;
+        if (this.public) {
+            // TODO: switch to Lazy config using "grantPublicAccess" mechanism instead?
+            // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-s3/lib/bucket.ts#L850
+            const ownershipControls = new provider_aws_1.s3BucketOwnershipControls.S3BucketOwnershipControls(this, "OwnershipControls", {
+                bucket: this.resource.bucket,
+                rule: {
+                    objectOwnership: "BucketOwnerPreferred",
+                },
+            });
+            const publicAccessBlock = new provider_aws_1.s3BucketPublicAccessBlock.S3BucketPublicAccessBlock(this, "PublicAccessBlock", {
+                bucket: this.resource.bucket,
+                blockPublicAcls: false,
+                blockPublicPolicy: false,
+                ignorePublicAcls: false,
+                restrictPublicBuckets: false,
+            });
+            new provider_aws_1.s3BucketAcl.S3BucketAcl(this, "PublicAcl", {
+                bucket: this.resource.bucket,
+                acl: "public-read",
+                dependsOn: [ownershipControls, publicAccessBlock],
+            });
+            this.addToResourcePolicy(new iam.PolicyStatement({
+                resources: [this.arnForObjects("*")],
+                actions: ["s3:GetObject"],
+                principals: [new iam.AnyPrincipal()],
+            }));
+            // // policy depends on public access block?
+            // // is this needed?
+            // if (policyDependable && policyDependable instanceof Construct) {
+            //   policyDependable.node.addDependency(publicAccessBlock);
+            // }
+        }
+        if (corsConfig) {
+            this.corsConfig = new provider_aws_1.s3BucketCorsConfiguration.S3BucketCorsConfiguration(this, "CorsConfig", {
+                bucket: this.resource.bucket,
+                ...corsConfig,
+            });
+        }
+        let originAccessIdentity;
+        if (cloudfrontAccess?.enabled) {
+            const oai = new _1.OriginAccessIdentity(this, "OriginAccessIdentity", {
+                comment: `OAI for ${this.resource.bucket}`,
+            });
+            originAccessIdentity = oai.cloudFrontOriginAccessIdentityPath;
+            const resources = (cloudfrontAccess.keyPatterns ?? ["*"]).map((keyPattern) => this.arnForObjects(keyPattern));
+            this.addToResourcePolicy(new iam.PolicyStatement({
+                resources,
+                actions: ["s3:GetObject"],
+                principals: [oai.grantPrincipal],
+            }));
+        }
+        if (this.eventBridgeEnabled) {
+            this.enableEventBridgeNotification();
+        }
+        //register outputs
+        this._outputs = {
+            name: this.resource.bucket,
+            arn: this.resource.arn,
+            domainName: this.resource.bucketDomainName,
+            regionalDomainName: this.resource.bucketRegionalDomainName,
+            websiteDomainName: this.websiteConfig?.websiteDomain,
+            websiteUrl: this.websiteConfig?.websiteEndpoint,
+            originAccessIdentity,
+        };
+    }
+    /**
+     * Adds a statement to the resource policy for a principal (i.e.
+     * account/role/service) to perform actions on this bucket and/or its
+     * contents. Use `bucketArn` and `arnForObjects(keys)` to obtain ARNs for
+     * this bucket or objects.
+     *
+     * Note that the policy statement may or may not be added to the policy.
+     * For example, when an `IBucket` is created from an existing bucket,
+     * it's not possible to tell whether the bucket already has a policy
+     * attached, let alone to re-use that policy to add more statements to it.
+     * So it's safest to do nothing in these cases.
+     *
+     * @param permission the policy statement to be added to the bucket's
+     * policy.
+     * @returns metadata about the execution of this method. If the policy
+     * was not added, the value of `statementAdded` will be `false`. You
+     * should always check this value to make sure that the operation was
+     * actually carried out. Otherwise, synthesis and deploy will terminate
+     * silently, which may be confusing.
+     */
+    addToResourcePolicy(permission) {
+        // TODO: re-add autoCreatePolicy option?
+        // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-s3/lib/bucket.ts#L652
+        if (!this.policy) {
+            this.policy = new _1.BucketPolicy(this, "Policy", { bucket: this });
+        }
+        if (this.policy) {
+            this.policy.document.addStatements(permission);
+            return { statementAdded: true, policyDependable: this.policy };
+        }
+        return { statementAdded: false };
+    }
+    /**
+     * Grant read permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If encryption is used, permission to use the key to decrypt the contents
+     * of the bucket will also be granted to the same principal.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.
+     */
+    grantRead(identity, objectsKeyPattern = "*") {
+        return this.grant(identity, perms.BUCKET_READ_ACTIONS, perms.KEY_READ_ACTIONS, this.resource.arn, this.arnForObjects(objectsKeyPattern));
+    }
+    grantWrite(identity, objectsKeyPattern = "*", allowedActionPatterns = []) {
+        const grantedWriteActions = allowedActionPatterns.length > 0
+            ? allowedActionPatterns
+            : this.writeActions;
+        return this.grant(identity, grantedWriteActions, perms.KEY_WRITE_ACTIONS, this.resource.arn, this.arnForObjects(objectsKeyPattern));
+    }
+    /**
+     * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.
+     */
+    grantPut(identity, objectsKeyPattern = "*") {
+        return this.grant(identity, perms.BUCKET_PUT_ACTIONS, perms.KEY_WRITE_ACTIONS, this.arnForObjects(objectsKeyPattern));
+    }
+    grantPutAcl(identity, objectsKeyPattern = "*") {
+        return this.grant(identity, perms.BUCKET_PUT_ACL_ACTIONS, [], this.arnForObjects(objectsKeyPattern));
+    }
+    /**
+     * Grants s3:DeleteObject* permission to an IAM principal for objects
+     * in this bucket.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.
+     */
+    grantDelete(identity, objectsKeyPattern = "*") {
+        return this.grant(identity, perms.BUCKET_DELETE_ACTIONS, [], this.arnForObjects(objectsKeyPattern));
+    }
+    grantReadWrite(identity, objectsKeyPattern = "*") {
+        const bucketActions = perms.BUCKET_READ_ACTIONS.concat(this.writeActions);
+        // we need unique permissions because some permissions are common between read and write key actions
+        const keyActions = [
+            ...new Set([...perms.KEY_READ_ACTIONS, ...perms.KEY_WRITE_ACTIONS]),
+        ];
+        return this.grant(identity, bucketActions, keyActions, this.resource.arn, this.arnForObjects(objectsKeyPattern));
+    }
+    // TODO: currently only supported through `props.public` in constructor
+    // /**
+    //  * Allows unrestricted access to objects from this bucket.
+    //  *
+    //  * IMPORTANT: This permission allows anyone to perform actions on S3 objects
+    //  * in this bucket, which is useful for when you configure your bucket as a
+    //  * website and want everyone to be able to read objects in the bucket without
+    //  * needing to authenticate.
+    //  *
+    //  * Without arguments, this method will grant read ("s3:GetObject") access to
+    //  * all objects ("*") in the bucket.
+    //  *
+    //  * The method returns the `iam.Grant` object, which can then be modified
+    //  * as needed. For example, you can add a condition that will restrict access only
+    //  * to an IPv4 range like this:
+    //  *
+    //  *     const grant = bucket.grantPublicAccess();
+    //  *     grant.resourceStatement!.addCondition(‘IpAddress’, { “aws:SourceIp”: “54.240.143.0/24” });
+    //  *
+    //  * Note that if this `IBucket` refers to an existing bucket, possibly not
+    //  * managed by CloudFormation, this method will have no effect, since it's
+    //  * impossible to modify the policy of an existing bucket.
+    //  *
+    //  * @param keyPrefix the prefix of S3 object keys (e.g. `home/*`). Default is "*".
+    //  * @param allowedActions the set of S3 actions to allow. Default is "s3:GetObject".
+    //  */
+    // public grantPublicAccess(keyPrefix = "*", ...allowedActions: string[]) {
+    //   if (!this.public) {
+    //     throw new Error("Cannot grant public access when 'public' is enabled");
+    //   }
+    //   // TDOO: This should create publicAccess resource
+    //   allowedActions =
+    //     allowedActions.length > 0 ? allowedActions : ["s3:GetObject"];
+    //   return iam.Grant.addToPrincipalOrResource({
+    //     actions: allowedActions,
+    //     resourceArns: [this.arnForObjects(keyPrefix)],
+    //     grantee: new iam.AnyPrincipal(),
+    //     resource: this,
+    //   });
+    // }
+    /**
+     * Adds a bucket notification event destination.
+     *
+     * S3 Buckets only support a single notification configuration resource.
+     * Declaring multiple `aws_s3_bucket_notification` resources to the same
+     * S3 Bucket will cause a perpetual difference in configuration.
+     *
+     * Calling this function will overwrite any existing event notifications configured
+     * for the S3 bucket outside of this beacon.
+     *
+     * @param event The event to trigger the notification
+     * @param dest The notification destination (Lambda, SNS Topic or SQS Queue)
+     *
+     * @param filters S3 object key filter rules to determine which objects
+     * trigger this event. Each filter must include a `prefix` and/or `suffix`
+     * that will be matched against the s3 object key. Refer to the S3 Developer Guide
+     * for details about allowed filter rules.
+     *
+     * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html#notification-how-to-filtering
+     *
+     * @example
+     *
+     *    declare const myFunction: compute.Function;
+     *    const bucket = new storage.Bucket(this, 'MyBucket');
+     *    bucket.addEventNotification(s3.EventType.OBJECT_CREATED, new s3n.LambdaDestination(myFunction), {prefix: 'home/myusername/*'});
+     *
+     * @see
+     * https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html
+     */
+    addEventNotification(event, dest, ...filters) {
+        // TODO: This blocks adding notifications outside of the Stack owning the bucket...
+        // AWS-CDK works around this by using a CustomResource handler (Lambda function) which modifies
+        // the bucket policy in place (and CFN does not manage the actual bucket policy, so no tf state!)
+        this.withNotifications((notifications) => notifications.addNotification(event, dest, ...filters));
+    }
+    withNotifications(cb) {
+        if (!this.notifications) {
+            this.notifications = new _1.BucketNotifications(this, "Notifications", {
+                bucket: this,
+            });
+        }
+        cb(this.notifications);
+    }
+    /**
+     * Subscribes a destination to receive notifications when an object is
+     * created in the bucket. This is identical to calling
+     * `onEvent(EventType.OBJECT_CREATED)`.
+     *
+     * @param dest The notification destination (see onEvent)
+     * @param filters Filters (see onEvent)
+     */
+    addObjectCreatedNotification(dest, ...filters) {
+        return this.addEventNotification(EventType.OBJECT_CREATED, dest, ...filters);
+    }
+    /**
+     * Subscribes a destination to receive notifications when an object is
+     * removed from the bucket. This is identical to calling
+     * `onEvent(EventType.OBJECT_REMOVED)`.
+     *
+     * @param dest The notification destination (see onEvent)
+     * @param filters Filters (see onEvent)
+     */
+    addObjectRemovedNotification(dest, ...filters) {
+        return this.addEventNotification(EventType.OBJECT_REMOVED, dest, ...filters);
+    }
+    /**
+     * Enables event bridge notification, causing all events below to be sent to EventBridge:
+     *
+     * - Object Deleted (DeleteObject)
+     * - Object Deleted (Lifecycle expiration)
+     * - Object Restore Initiated
+     * - Object Restore Completed
+     * - Object Restore Expired
+     * - Object Storage Class Changed
+     * - Object Access Tier Changed
+     * - Object ACL Updated
+     * - Object Tags Added
+     * - Object Tags Deleted
+     */
+    enableEventBridgeNotification() {
+        this.withNotifications((notifications) => notifications.enableEventBridgeNotification());
+    }
+    grant(grantee, bucketActions, _keyActions, resourceArn, ...otherResourceArns) {
+        const resources = [resourceArn, ...otherResourceArns];
+        const ret = iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions: bucketActions,
+            resourceArns: resources,
+            resource: this,
+        });
+        // TODO: re-add KMS support
+        // if (this.encryptionKey && keyActions && keyActions.length !== 0) {
+        //   this.encryptionKey.grant(grantee, ...keyActions);
+        // }
+        return ret;
+    }
+    get writeActions() {
+        return [...perms.BUCKET_DELETE_ACTIONS, ...perms.BUCKET_PUT_ACTIONS];
+    }
+    /**
+     * Add a source to the bucket.
+     *
+     * @param props The properties of the source to add
+     */
+    addSource(props, sourceId) {
+        if (this.versioned) {
+            /**
+             * If you enable versioning on a bucket for the first time, it might take up to 15 minutes
+             * for the change to be fully propagated. We recommend that you wait for 15 minutes after
+             * enabling versioning before issuing write operations (PUT or DELETE) on objects in the bucket.
+             *
+             * Write operations issued before this conversion is complete may apply to unversioned objects.
+             */
+            if (!this.sourceSleep) {
+                this.sourceSleep = new provider_time_1.sleep.Sleep(this, "VersioningSleep", {
+                    createDuration: "15m",
+                });
+            }
+        }
+        const indexedSource = this.sources.find((sourceIndex) => sourceIndex.props === props);
+        if (indexedSource) {
+            if (sourceId && sourceId !== indexedSource.id) {
+                throw new Error(`Duplicate bucket source for ${indexedSource.id} and ${sourceId}.`);
+            }
+            return indexedSource.id;
+        }
+        const nextIndex = this.sources.length;
+        const id = sourceId ?? `source-${nextIndex}`;
+        // ensure id (if provided) is unique within Bucket
+        if (this.sources.some((sourceIndex) => sourceIndex.id === id)) {
+            throw new Error(`Duplicate source id ${id}. SourceIds must be unique within a Bucket.`);
+        }
+        this.sources.push({
+            props: {
+                ...props,
+                bucket: this,
+                dependsOn: this.sourceSleep ? [this.sourceSleep] : undefined,
+            },
+            id,
+        });
+        return id;
+    }
+    isWebsite() {
+        return this._isWebsite;
+    }
+    /**
+     * The https URL of an S3 object. Specify `regional: false` at the options
+     * for non-regional URLs. For example:
+     *
+     * - `https://s3.us-west-1.amazonaws.com/onlybucket`
+     * - `https://s3.us-west-1.amazonaws.com/bucket/key`
+     * - `https://s3.cn-north-1.amazonaws.com.cn/china-bucket/mykey`
+     *
+     * @param key The S3 key of the object. If not specified, the URL of the
+     *      bucket is returned.
+     * @returns an ObjectS3Url token
+     */
+    urlForObject(key) {
+        const stack = __1.AwsStack.ofAwsConstruct(this);
+        const prefix = `https://s3.${this.env.region}.${stack.urlSuffix}/`;
+        if (typeof key !== "string") {
+            return this.urlJoin(prefix, this.bucketName);
+        }
+        return this.urlJoin(prefix, this.bucketName, key);
+    }
+    /**
+     * The S3 URL of an S3 object. For example:
+     *
+     * - `s3://onlybucket`
+     * - `s3://bucket/key`
+     *
+     * @param key The S3 key of the object. If not specified, the S3 URL of the
+     *      bucket is returned.
+     * @returns an ObjectS3Url token
+     */
+    s3UrlForObject(key) {
+        const prefix = "s3://";
+        if (typeof key !== "string") {
+            return this.urlJoin(prefix, this.bucketName);
+        }
+        return this.urlJoin(prefix, this.bucketName, key);
+    }
+    /**
+     * Returns an ARN that represents all objects within the bucket that match
+     * the key pattern specified. To represent all keys, specify ``"*"``.
+     *
+     * If you need to specify a keyPattern with multiple components, concatenate them into a single string, e.g.:
+     *
+     *   arnForObjects(`home/${team}/${user}/*`)
+     *
+     */
+    arnForObjects(keyPattern) {
+        return `${this.resource.arn}/${keyPattern}`;
+    }
+    // https://github.com/aws/aws-cdk/blob/v2.140.0/packages/aws-cdk-lib/aws-s3/lib/bucket.ts#L953
+    urlJoin(...components) {
+        return components.reduce((result, component) => {
+            if (result.endsWith("/")) {
+                result = result.slice(0, -1);
+            }
+            if (component.startsWith("/")) {
+                component = component.slice(1);
+            }
+            return `${result}/${component}`;
+        });
+    }
+    /**
+     * Adds an iam statement to enforce SSL requests only.
+     */
+    enforceSSLStatement() {
+        const statement = new iam.PolicyStatement({
+            actions: ["s3:*"],
+            condition: [
+                {
+                    test: "Bool",
+                    variable: "aws:SecureTransport",
+                    values: ["false"],
+                },
+            ],
+            effect: iam.Effect.DENY,
+            resources: [this.resource.arn, this.arnForObjects("*")],
+            principals: [new iam.AnyPrincipal()],
+        });
+        this.addToResourcePolicy(statement);
+    }
+    /**
+     * Adds an iam statement to allow requests with a minimum TLS
+     * version only.
+     */
+    minimumTLSVersionStatement(minimumTLSVersion) {
+        if (!minimumTLSVersion)
+            return;
+        const statement = new iam.PolicyStatement({
+            actions: ["s3:*"],
+            condition: [
+                {
+                    test: "NumericLessThan",
+                    variable: "s3:TlsVersion",
+                    values: [minimumTLSVersion.toString()],
+                },
+            ],
+            effect: iam.Effect.DENY,
+            resources: [this.resource.arn, this.arnForObjects("*")],
+            principals: [new iam.AnyPrincipal()],
+        });
+        this.addToResourcePolicy(statement);
+    }
+    /**
+     * Adds resource to the Terraform JSON output at Synth time.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        /**
+         * A preparing resolve might add new resources to the stack
+         *
+         * should not add resources if no bucket sources are defined
+         */
+        if (Object.keys(this.sources).length === 0) {
+            return {};
+        }
+        for (const source of this.sources) {
+            // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag
+            // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48
+            if (this.node.tryFindChild(source.id))
+                continue; // ignore if already generated
+            new _1.BucketSource(this, source.id, source.props);
+        }
+        return {};
+    }
+}
+exports.Bucket = Bucket;
+_a = JSII_RTTI_SYMBOL_1;
+Bucket[_a] = { fqn: "terraconstructs.aws.storage.Bucket", version: "0.0.8" };
+/**
+ * Storage class to move an object to
+ */
+var StorageClass;
+(function (StorageClass) {
+    /**
+     * Storage class for data that is accessed less frequently, but requires rapid
+     * access when needed.
+     *
+     * Has lower availability than Standard storage.
+     */
+    StorageClass["INFREQUENT_ACCESS"] = "STANDARD_IA";
+    /**
+     * Infrequent Access that's only stored in one availability zone.
+     *
+     * Has lower availability than standard InfrequentAccess.
+     */
+    StorageClass["ONE_ZONE_INFREQUENT_ACCESS"] = "ONEZONE_IA";
+    /**
+     * Storage class for long-term archival that can take between minutes and
+     * hours to access.
+     *
+     * Use for archives where portions of the data might need to be retrieved in
+     * minutes. Data stored in the GLACIER storage class has a minimum storage
+     * duration period of 90 days and can be accessed in as little as 1-5 minutes
+     * using expedited retrieval. If you delete an object before the 90-day
+     * minimum, you are charged for 90 days.
+     */
+    StorageClass["GLACIER"] = "GLACIER";
+    /**
+     * Storage class for long-term archival that can be accessed in a few milliseconds.
+     *
+     * It is ideal for data that is accessed once or twice per quarter, and
+     * that requires immediate access. Data stored in the GLACIER_IR storage class
+     * has a minimum storage duration period of 90 days and can be accessed in
+     * as milliseconds. If you delete an object before the 90-day minimum,
+     * you are charged for 90 days.
+     */
+    StorageClass["GLACIER_INSTANT_RETRIEVAL"] = "GLACIER_IR";
+    /**
+     * Use for archiving data that rarely needs to be accessed. Data stored in the
+     * DEEP_ARCHIVE storage class has a minimum storage duration period of 180
+     * days and a default retrieval time of 12 hours. If you delete an object
+     * before the 180-day minimum, you are charged for 180 days. For pricing
+     * information, see Amazon S3 Pricing.
+     */
+    StorageClass["DEEP_ARCHIVE"] = "DEEP_ARCHIVE";
+    /**
+     * The INTELLIGENT_TIERING storage class is designed to optimize storage costs
+     * by automatically moving data to the most cost-effective storage access
+     * tier, without performance impact or operational overhead.
+     * INTELLIGENT_TIERING delivers automatic cost savings by moving data on a
+     * granular object level between two access tiers, a frequent access tier and
+     * a lower-cost infrequent access tier, when access patterns change. The
+     * INTELLIGENT_TIERING storage class is ideal if you want to optimize storage
+     * costs automatically for long-lived data when access patterns are unknown or
+     * unpredictable.
+     */
+    StorageClass["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING";
+})(StorageClass || (exports.StorageClass = StorageClass = {}));
+/**
+ * Notification event types.
+ * @link https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-event-types-and-destinations.html#supported-notification-event-types
+ */
+var EventType;
+(function (EventType) {
+    /**
+     * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using
+     * these event types, you can enable notification when an object is created
+     * using a specific API, or you can use the s3:ObjectCreated:* event type to
+     * request notification regardless of the API that was used to create an
+     * object.
+     */
+    EventType["OBJECT_CREATED"] = "s3:ObjectCreated:*";
+    /**
+     * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using
+     * these event types, you can enable notification when an object is created
+     * using a specific API, or you can use the s3:ObjectCreated:* event type to
+     * request notification regardless of the API that was used to create an
+     * object.
+     */
+    EventType["OBJECT_CREATED_PUT"] = "s3:ObjectCreated:Put";
+    /**
+     * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using
+     * these event types, you can enable notification when an object is created
+     * using a specific API, or you can use the s3:ObjectCreated:* event type to
+     * request notification regardless of the API that was used to create an
+     * object.
+     */
+    EventType["OBJECT_CREATED_POST"] = "s3:ObjectCreated:Post";
+    /**
+     * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using
+     * these event types, you can enable notification when an object is created
+     * using a specific API, or you can use the s3:ObjectCreated:* event type to
+     * request notification regardless of the API that was used to create an
+     * object.
+     */
+    EventType["OBJECT_CREATED_COPY"] = "s3:ObjectCreated:Copy";
+    /**
+     * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using
+     * these event types, you can enable notification when an object is created
+     * using a specific API, or you can use the s3:ObjectCreated:* event type to
+     * request notification regardless of the API that was used to create an
+     * object.
+     */
+    EventType["OBJECT_CREATED_COMPLETE_MULTIPART_UPLOAD"] = "s3:ObjectCreated:CompleteMultipartUpload";
+    /**
+     * By using the ObjectRemoved event types, you can enable notification when
+     * an object or a batch of objects is removed from a bucket.
+     *
+     * You can request notification when an object is deleted or a versioned
+     * object is permanently deleted by using the s3:ObjectRemoved:Delete event
+     * type. Or you can request notification when a delete marker is created for
+     * a versioned object by using s3:ObjectRemoved:DeleteMarkerCreated. For
+     * information about deleting versioned objects, see Deleting Object
+     * Versions. You can also use a wildcard s3:ObjectRemoved:* to request
+     * notification anytime an object is deleted.
+     *
+     * You will not receive event notifications from automatic deletes from
+     * lifecycle policies or from failed operations.
+     */
+    EventType["OBJECT_REMOVED"] = "s3:ObjectRemoved:*";
+    /**
+     * By using the ObjectRemoved event types, you can enable notification when
+     * an object or a batch of objects is removed from a bucket.
+     *
+     * You can request notification when an object is deleted or a versioned
+     * object is permanently deleted by using the s3:ObjectRemoved:Delete event
+     * type. Or you can request notification when a delete marker is created for
+     * a versioned object by using s3:ObjectRemoved:DeleteMarkerCreated. For
+     * information about deleting versioned objects, see Deleting Object
+     * Versions. You can also use a wildcard s3:ObjectRemoved:* to request
+     * notification anytime an object is deleted.
+     *
+     * You will not receive event notifications from automatic deletes from
+     * lifecycle policies or from failed operations.
+     */
+    EventType["OBJECT_REMOVED_DELETE"] = "s3:ObjectRemoved:Delete";
+    /**
+     * By using the ObjectRemoved event types, you can enable notification when
+     * an object or a batch of objects is removed from a bucket.
+     *
+     * You can request notification when an object is deleted or a versioned
+     * object is permanently deleted by using the s3:ObjectRemoved:Delete event
+     * type. Or you can request notification when a delete marker is created for
+     * a versioned object by using s3:ObjectRemoved:DeleteMarkerCreated. For
+     * information about deleting versioned objects, see Deleting Object
+     * Versions. You can also use a wildcard s3:ObjectRemoved:* to request
+     * notification anytime an object is deleted.
+     *
+     * You will not receive event notifications from automatic deletes from
+     * lifecycle policies or from failed operations.
+     */
+    EventType["OBJECT_REMOVED_DELETE_MARKER_CREATED"] = "s3:ObjectRemoved:DeleteMarkerCreated";
+    /**
+     * Using restore object event types you can receive notifications for
+     * initiation and completion when restoring objects from the S3 Glacier
+     * storage class.
+     *
+     * You use s3:ObjectRestore:Post to request notification of object restoration
+     * initiation.
+     */
+    EventType["OBJECT_RESTORE_POST"] = "s3:ObjectRestore:Post";
+    /**
+     * Using restore object event types you can receive notifications for
+     * initiation and completion when restoring objects from the S3 Glacier
+     * storage class.
+     *
+     * You use s3:ObjectRestore:Completed to request notification of
+     * restoration completion.
+     */
+    EventType["OBJECT_RESTORE_COMPLETED"] = "s3:ObjectRestore:Completed";
+    /**
+     * Using restore object event types you can receive notifications for
+     * initiation and completion when restoring objects from the S3 Glacier
+     * storage class.
+     *
+     * You use s3:ObjectRestore:Delete to request notification of
+     * restoration completion.
+     */
+    EventType["OBJECT_RESTORE_DELETE"] = "s3:ObjectRestore:Delete";
+    /**
+     * You can use this event type to request Amazon S3 to send a notification
+     * message when Amazon S3 detects that an object of the RRS storage class is
+     * lost.
+     */
+    EventType["REDUCED_REDUNDANCY_LOST_OBJECT"] = "s3:ReducedRedundancyLostObject";
+    /**
+     * You receive this notification event when an object that was eligible for
+     * replication using Amazon S3 Replication Time Control failed to replicate.
+     */
+    EventType["REPLICATION_OPERATION_FAILED_REPLICATION"] = "s3:Replication:OperationFailedReplication";
+    /**
+     * You receive this notification event when an object that was eligible for
+     * replication using Amazon S3 Replication Time Control exceeded the 15-minute
+     * threshold for replication.
+     */
+    EventType["REPLICATION_OPERATION_MISSED_THRESHOLD"] = "s3:Replication:OperationMissedThreshold";
+    /**
+     * You receive this notification event for an object that was eligible for
+     * replication using the Amazon S3 Replication Time Control feature replicated
+     * after the 15-minute threshold.
+     */
+    EventType["REPLICATION_OPERATION_REPLICATED_AFTER_THRESHOLD"] = "s3:Replication:OperationReplicatedAfterThreshold";
+    /**
+     * You receive this notification event for an object that was eligible for
+     * replication using Amazon S3 Replication Time Control but is no longer tracked
+     * by replication metrics.
+     */
+    EventType["REPLICATION_OPERATION_NOT_TRACKED"] = "s3:Replication:OperationNotTracked";
+    /**
+     * By using the LifecycleExpiration event types, you can receive a notification
+     * when Amazon S3 deletes an object based on your S3 Lifecycle configuration.
+     */
+    EventType["LIFECYCLE_EXPIRATION"] = "s3:LifecycleExpiration:*";
+    /**
+     * The s3:LifecycleExpiration:Delete event type notifies you when an object
+     * in an unversioned bucket is deleted.
+     * It also notifies you when an object version is permanently deleted by an
+     * S3 Lifecycle configuration.
+     */
+    EventType["LIFECYCLE_EXPIRATION_DELETE"] = "s3:LifecycleExpiration:Delete";
+    /**
+     * The s3:LifecycleExpiration:DeleteMarkerCreated event type notifies you
+     * when S3 Lifecycle creates a delete marker when a current version of an
+     * object in versioned bucket is deleted.
+     */
+    EventType["LIFECYCLE_EXPIRATION_DELETE_MARKER_CREATED"] = "s3:LifecycleExpiration:DeleteMarkerCreated";
+    /**
+     * You receive this notification event when an object is transitioned to
+     * another Amazon S3 storage class by an S3 Lifecycle configuration.
+     */
+    EventType["LIFECYCLE_TRANSITION"] = "s3:LifecycleTransition";
+    /**
+     * You receive this notification event when an object within the
+     * S3 Intelligent-Tiering storage class moved to the Archive Access tier or
+     * Deep Archive Access tier.
+     */
+    EventType["INTELLIGENT_TIERING"] = "s3:IntelligentTiering";
+    /**
+     * By using the ObjectTagging event types, you can enable notification when
+     * an object tag is added or deleted from an object.
+     */
+    EventType["OBJECT_TAGGING"] = "s3:ObjectTagging:*";
+    /**
+     * The s3:ObjectTagging:Put event type notifies you when a tag is PUT on an
+     * object or an existing tag is updated.
+  
+     */
+    EventType["OBJECT_TAGGING_PUT"] = "s3:ObjectTagging:Put";
+    /**
+     * The s3:ObjectTagging:Delete event type notifies you when a tag is removed
+     * from an object.
+     */
+    EventType["OBJECT_TAGGING_DELETE"] = "s3:ObjectTagging:Delete";
+    /**
+     * You receive this notification event when an ACL is PUT on an object or when
+     * an existing ACL is changed.
+     * An event is not generated when a request results in no change to an
+     * object’s ACL.
+     */
+    EventType["OBJECT_ACL_PUT"] = "s3:ObjectAcl:Put";
+})(EventType || (exports.EventType = EventType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bucket.js","sourceRoot":"","sources":["../../../src/aws/storage/bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  s3Bucket,\n  s3BucketAcl,\n  s3BucketCorsConfiguration,\n  s3BucketOwnershipControls,\n  s3BucketPublicAccessBlock,\n  s3BucketWebsiteConfiguration,\n  s3BucketLifecycleConfiguration,\n  s3BucketVersioning,\n} from \"@cdktf/provider-aws\";\nimport { sleep } from \"@cdktf/provider-time\";\nimport { Construct } from \"constructs\";\nimport {\n  BucketSource,\n  BucketSourceProps,\n  WebsiteConfig,\n  CorsConfig,\n  LifecycleConfigurationRule,\n  OriginAccessIdentity,\n  BucketPolicy,\n  BucketNotifications,\n  IBucketNotificationDestination,\n} from \".\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n  AwsStack,\n} from \"..\";\nimport * as iam from \"../iam\";\nimport * as perms from \"./bucket-perms\";\n\nexport interface CloudfrontAccessConfig {\n  /**\n   * Enable Cloudfront access via Origin Access Identity.\n   */\n  readonly enabled: boolean;\n  /**\n   * Object key patterns for cloudfront access.\n   *\n   * @default \"*\"\n   */\n  readonly keyPatterns?: string[];\n}\n\nexport interface BucketProps extends AwsConstructProps {\n  /**\n   * The path(s) to static directories or files to upload, relative to the Stack file.\n   *\n   * @example \"./dist\"\n   * @default - No files are uploaded.\n   */\n  readonly sources?: string | string[] | AddSourceOptions[];\n\n  // TODO: Add support to pass domain props (for route53 alias?)\n\n  /**\n   * Enable public read access for all the files in the bucket.\n   *\n   * Enable this only if you're not using CDN (CloudFront) to serve files from the bucket.\n   * Should only be turned on if you want to host public files directly from the bucket.\n   *\n   * @default `false`\n   */\n  readonly public?: boolean;\n\n  /**\n   * A name for the bucket.\n   *\n   * Must be lowercase and between 3 (min) and 63 (max) characters long.\n   *\n   * The name must not be in the format [bucket_name]--[azid]--x-s3. Use the\n   * `aws_s3_directory_bucket` resource to manage S3 Express buckets.\n   *\n   * A full list of bucket naming rules [may be found here](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html).\n   *\n   * @default - If omitted, Refer to `namePrefix`.\n   */\n  readonly bucketName?: string;\n\n  /**\n   * Creates a unique name beginning with the specified prefix.\n   * Conflicts with `bucketName`.\n   *\n   * Terraform Prefixes must reserve 26 characters for the terraform generated suffix.\n   *\n   * @default - If omitted, ET will assign a random, unique name prefixed by GridUUID.\n   */\n  readonly namePrefix?: string;\n\n  /**\n   * Boolean that indicates all objects (including any locked objects)\n   * should be deleted from the bucket when the bucket is destroyed\n   * so that the bucket can be destroyed without error.\n   *\n   * These objects are not recoverable. This only deletes objects when\n   * the bucket is destroyed, not when setting this parameter to true.\n   *\n   * Once this parameter is set to true, there must be a successful\n   * terraform apply run before a destroy is required to update this\n   * value in the resource state.\n   *\n   * Without a successful terraform apply after this parameter is set,\n   * this flag will have no effect. If setting this field in the same\n   * operation that would require replacing the bucket or destroying\n   * the bucket, this flag will not work.\n   *\n   * Additionally when importing a bucket, a successful terraform apply\n   * is required to set this value in state before it will take effect\n   * on a destroy operation.\n   *\n   * @default false\n   */\n  readonly forceDestroy?: boolean;\n\n  /**\n   * Provides an S3 bucket website configuration resource.\n   *\n   * Important: Amazon S3 website endpoints do not support HTTPS or access points.\n   * If you want to use HTTPS, you can use edge Distribution to serve a static\n   * website hosted in a bucket.\n   *\n   * Use OriginAccessIdentity property to control ingress through edge Distribution.\n   *\n   * For more information, see [Hosting Websites on S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html).\n   */\n  readonly websiteConfig?: WebsiteConfig;\n\n  /**\n   * Provides an S3 bucket CORS configuration resource.\n   *\n   * For more information about CORS, go to\n   * [Enabling Cross-Origin Resource Sharing](https://docs.aws.amazon.com/AmazonS3/latest/userguide/cors.html)\n   * in the Amazon S3 User Guide.\n   */\n  readonly corsConfig?: CorsConfig;\n\n  /**\n   * One or more Lifecycle rules. Each rule consists of the following:\n   *\n   *  - Rule id\n   *  - Filter identifying objects to which the rule applies\n   *  - One or more transition or expiration actions\n   *\n   * For more information see the Amazon S3 User Guide on [Lifecycle Configuration Elements](https://docs.aws.amazon.com/AmazonS3/latest/userguide/intro-lifecycle-rules.html).\n   */\n  readonly lifecycleRules?: LifecycleConfigurationRule[];\n\n  /**\n   * Controls versioning on the S3 bucket.\n   *\n   * Setting this to false will suspend versioning if the associated S3 bucket is versioned.\n   *\n   * If you are enabling versioning on the bucket for the first time, AWS recommends that you wait for 15 minutes after enabling versioning before issuing write operations (PUT or DELETE) on objects in the bucket.\n   * This will cause 15m delay if `path` is configured.\n   *\n   * @default false\n   */\n  readonly versioned?: boolean;\n\n  /**\n   * Whether this bucket should send notifications to Amazon EventBridge or not.\n   *\n   * @default false\n   */\n  readonly eventBridgeEnabled?: boolean;\n\n  /**\n   * Enforces SSL for requests. S3.5 of the AWS Foundational Security Best Practices Regarding S3.\n   * @see https://docs.aws.amazon.com/config/latest/developerguide/s3-bucket-ssl-requests-only.html\n   *\n   * @default false\n   */\n  readonly enforceSSL?: boolean;\n\n  /**\n   * Enforces minimum TLS version for requests.\n   *\n   * Requires `enforceSSL` to be enabled.\n   *\n   * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/amazon-s3-policy-keys.html#example-object-tls-version\n   *\n   * @default No minimum TLS version is enforced.\n   */\n  readonly minimumTLSVersion?: number;\n\n  /**\n   * Enable Cloudfront access via Origin Access Identity.\n   *\n   * Note: recommended to migrate to OAC in future.\n   *\n   * @default - no cloudfront access\n   */\n  readonly cloudfrontAccess?: CloudfrontAccessConfig;\n\n  // TODO: Add flag to register Bucket Source outputs?\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface BucketOutputs {\n  /**\n   * AWS Bucket name\n   * @attribute\n   */\n  readonly name: string;\n\n  /**\n   * AWS Bucket arn\n   * @attribute\n   */\n  readonly arn: string;\n\n  /**\n   * The URL of the static website.\n   * @attribute\n   */\n  readonly websiteUrl?: string;\n\n  /**\n   * The Domain name of the static website.\n   * @attribute\n   */\n  readonly websiteDomainName?: string;\n\n  /**\n   * The IPv4 DNS name of the specified bucket.\n   * @attribute\n   */\n  readonly domainName: string;\n\n  /**\n   * The regional domain name of the specified bucket.\n   * @attribute\n   */\n  readonly regionalDomainName: string;\n\n  /**\n   * Origin Access Identity, if cloudfrontAccess is enabled.\n   * @attribute\n   */\n  readonly originAccessIdentity?: string;\n}\n\n/**\n * Imported or created Bucket attributes\n */\nexport interface IBucket extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly bucketOutputs: BucketOutputs;\n\n  /**\n   * AWS Bucket name\n   */\n  readonly bucketName: string;\n  /**\n   * AWS Bucket arn\n   */\n  readonly bucketArn: string;\n\n  /** Whether the bucket has versioning enabled */\n  readonly versioned: boolean;\n\n  /** The hosted Zone Id for the bucket */\n  readonly hostedZoneId: string;\n\n  /**\n   * The Domain name of the static website.\n   * @attribute\n   */\n  readonly websiteDomainName?: string;\n\n  /**\n   * Enable public read access for all the files in the bucket.\n   *\n   * This explicitly disables the default S3 bucket security settings. This\n   * should be done with caution, as all bucket objects become publicly exposed.\n   *\n   * You don't need to enable this if you're using CloudFront to serve files from the bucket.\n   *\n   * @default `false`\n   */\n  public?: boolean;\n\n  /**\n   * The resource policy associated with this bucket.\n   *\n   * If `autoCreatePolicy` is true, a `BucketPolicy` will be created upon the\n   * first call to addToResourcePolicy(s).\n   */\n  policy?: BucketPolicy;\n\n  /**\n   * Add a source of files for upload to the bucket.\n   */\n  addSource(props: AddSourceOptions, sourceId?: string): string;\n\n  /**\n   * If this bucket has been configured for static website hosting.\n   */\n  isWebsite(): this is {\n    websiteDomainName: string;\n    bucketOutputs: { websiteUrl: string; websiteDomainName: string };\n  };\n\n  /**\n   * The https URL of an S3 object. For example:\n   *\n   * - `https://s3.us-west-1.amazonaws.com/onlybucket`\n   * - `https://s3.us-west-1.amazonaws.com/bucket/key`\n   * - `https://s3.cn-north-1.amazonaws.com.cn/china-bucket/mykey`\n   * @param key The S3 key of the object. If not specified, the URL of the\n   *      bucket is returned.\n   * @returns an ObjectS3Url token\n   */\n  urlForObject(key?: string): string;\n\n  /**\n   * The S3 URL of an S3 object. For example:\n   * - `s3://onlybucket`\n   * - `s3://bucket/key`\n   * @param key The S3 key of the object. If not specified, the S3 URL of the\n   *      bucket is returned.\n   * @returns an ObjectS3Url token\n   */\n  s3UrlForObject(key?: string): string;\n\n  /**\n   * Returns an ARN that represents all objects within the bucket that match\n   * the key pattern specified. To represent all keys, specify ``\"*\"``.\n   */\n  arnForObjects(keyPattern: string): string;\n\n  /**\n   * Adds a statement to the resource policy for a principal (i.e.\n   * account/role/service) to perform actions on this bucket and/or its\n   * contents. Use `bucketArn` and `arnForObjects(keys)` to obtain ARNs for\n   * this bucket or objects.\n   *\n   * Note that the policy statement may or may not be added to the policy.\n   * For example, when an `IBucket` is created from an existing bucket,\n   * it's not possible to tell whether the bucket already has a policy\n   * attached, let alone to re-use that policy to add more statements to it.\n   * So it's safest to do nothing in these cases.\n   *\n   * @param permission the policy statement to be added to the bucket's\n   * policy.\n   * @returns metadata about the execution of this method. If the policy\n   * was not added, the value of `statementAdded` will be `false`. You\n   * should always check this value to make sure that the operation was\n   * actually carried out. Otherwise, synthesis and deploy will terminate\n   * silently, which may be confusing.\n   */\n  addToResourcePolicy(\n    permission: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult;\n\n  /**\n   * Grant read permissions for this bucket and it's contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If encryption is used, permission to use the key to decrypt the contents\n   * of the bucket will also be granted to the same principal.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   */\n  grantRead(identity: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;\n\n  /**\n   * Grant write permissions to this bucket to an IAM principal.\n   *\n   * If encryption is used, permission to use the key to encrypt the contents\n   * of written files will also be granted to the same principal.\n   *\n   * This does not include `s3:PutObjectAcl`, which could be used to grant read/write object access to IAM principals in other accounts.\n   *\n   * If you need the principal to have permissions to modify the ACLs,\n   * use the `grantPutAcl` method.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   * @param allowedActionPatterns Restrict the permissions to certain list of action patterns\n   */\n  grantWrite(\n    identity: iam.IGrantable,\n    objectsKeyPattern?: any,\n    allowedActionPatterns?: string[],\n  ): iam.Grant;\n\n  /**\n   * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.\n   *\n   * If encryption is used, permission to use the key to encrypt the contents\n   * of written files will also be granted to the same principal.\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   */\n  grantPut(identity: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;\n\n  /**\n   * Grant the given IAM identity permissions to modify the ACLs of objects in the given Bucket.\n   *\n   * calling `grantWrite` or `grantReadWrite` does not grant permissions to modify the ACLs of the objects;\n   * in this case, if you need to modify object ACLs, call this method explicitly.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantPutAcl(identity: iam.IGrantable, objectsKeyPattern?: string): iam.Grant;\n\n  /**\n   * Grants s3:DeleteObject* permission to an IAM principal for objects\n   * in this bucket.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   */\n  grantDelete(identity: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;\n\n  /**\n   * Grants read/write permissions for this bucket and it's contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to use the key for\n   * encrypt/decrypt will also be granted.\n   *\n   * This does not include `s3:PutObjectAcl`, which could be used to grant read/write object access to IAM principals in other accounts.\n   *\n   * If you need the principal to have permissions to modify the ACLs,\n   * use the `grantPutAcl` method.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   */\n  grantReadWrite(identity: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;\n\n  // /**\n  //  * Allows unrestricted access to objects from this bucket.\n  //  *\n  //  * IMPORTANT: This permission allows anyone to perform actions on S3 objects\n  //  * in this bucket, which is useful for when you configure your bucket as a\n  //  * website and want everyone to be able to read objects in the bucket without\n  //  * needing to authenticate.\n  //  *\n  //  * Without arguments, this method will grant read (\"s3:GetObject\") access to\n  //  * all objects (\"*\") in the bucket.\n  //  *\n  //  * The method returns the `iam.Grant` object, which can then be modified\n  //  * as needed. For example, you can add a condition that will restrict access only\n  //  * to an IPv4 range like this:\n  //  *\n  //  *     const grant = bucket.grantPublicAccess();\n  //  *     grant.resourceStatement!.addCondition(‘IpAddress’, { “aws:SourceIp”: “54.240.143.0/24” });\n  //  *\n  //  *\n  //  * @param keyPrefix the prefix of S3 object keys (e.g. `home/*`). Default is \"*\".\n  //  * @param allowedActions the set of S3 actions to allow. Default is \"s3:GetObject\".\n  //  * @returns The `iam.PolicyStatement` object, which can be used to apply e.g. conditions.\n  //  */\n  // grantPublicAccess(keyPrefix?: string, ...allowedActions: string[]): iam.Grant;\n\n  /**\n   * Adds a bucket notification event destination.\n   * @param event The event to trigger the notification\n   * @param dest The notification destination (Lambda, SNS Topic or SQS Queue)\n   *\n   * @param filters S3 object key filter rules to determine which objects\n   * trigger this event. Each filter must include a `prefix` and/or `suffix`\n   * that will be matched against the s3 object key. Refer to the S3 Developer Guide\n   * for details about allowed filter rules.\n   *\n   * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html#notification-how-to-filtering\n   *\n   * @example\n   *\n   *    declare const myLambda: lambda.Function;\n   *    const bucket = new s3.Bucket(this, 'MyBucket');\n   *    bucket.addEventNotification(s3.EventType.OBJECT_CREATED, new s3n.LambdaDestination(myLambda), {prefix: 'home/myusername/*'})\n   *\n   * @see\n   * https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html\n   */\n  addEventNotification(\n    event: EventType,\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void;\n\n  /**\n   * Subscribes a destination to receive notifications when an object is\n   * created in the bucket. This is identical to calling\n   * `onEvent(s3.EventType.OBJECT_CREATED)`.\n   *\n   * @param dest The notification destination (see onEvent)\n   * @param filters Filters (see onEvent)\n   */\n  addObjectCreatedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void;\n\n  /**\n   * Subscribes a destination to receive notifications when an object is\n   * removed from the bucket. This is identical to calling\n   * `onEvent(EventType.OBJECT_REMOVED)`.\n   *\n   * @param dest The notification destination (see onEvent)\n   * @param filters Filters (see onEvent)\n   */\n  addObjectRemovedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ): void;\n\n  /**\n   * Enables event bridge notification, causing all events below to be sent to EventBridge:\n   *\n   * - Object Deleted (DeleteObject)\n   * - Object Deleted (Lifecycle expiration)\n   * - Object Restore Initiated\n   * - Object Restore Completed\n   * - Object Restore Expired\n   * - Object Storage Class Changed\n   * - Object Access Tier Changed\n   * - Object ACL Updated\n   * - Object Tags Added\n   * - Object Tags Deleted\n   */\n  enableEventBridgeNotification(): void;\n}\n\n/**\n * The `Bucket` beacon provides an [AWS S3 Bucket](https://aws.amazon.com/s3/).\n *\n * ```ts\n * new storage.Bucket(stack, \"MyWebsite\", {\n *   path: path.join(__dirname, \"dist\"),\n * });\n * ```\n *\n * #### Public read access\n *\n * Enables `public` read access for all the files in the bucket. Dangerous and\n * recommended to use edge.Distribution instead.\n *\n * Useful for hosting public files directly from S3.\n *\n * ```ts\n * new storage.Bucket(\"MyBucket\", {\n *   public: true\n * });\n * ```\n *\n * @resource aws_s3_bucket\n * @terraconstruct storage.IBucket\n */\n\nexport class Bucket extends AwsConstructBase implements IBucket {\n  // TODO: Add static fromLookup?\n  protected readonly resource: s3Bucket.S3Bucket;\n  protected readonly websiteConfig?: s3BucketWebsiteConfiguration.S3BucketWebsiteConfiguration;\n  protected readonly corsConfig?: s3BucketCorsConfiguration.S3BucketCorsConfiguration;\n\n  /** @internal */\n  private readonly sources: SourceIndex[] = [];\n  /** @internal */\n  private readonly _versioned: boolean;\n  public get versioned(): boolean {\n    return this._versioned;\n  }\n\n  /** @internal */\n  private readonly _isWebsite: boolean;\n  /** @internal */\n  private sourceSleep?: sleep.Sleep;\n\n  /** @internal */\n  private readonly _outputs: BucketOutputs;\n  public get bucketOutputs(): BucketOutputs {\n    return this._outputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this.bucketOutputs;\n  }\n\n  public get bucketName(): string {\n    return this.resource.bucket;\n  }\n  public get bucketArn(): string {\n    return this.resource.arn;\n  }\n  public get hostedZoneId(): string {\n    return this.resource.hostedZoneId;\n  }\n  public get websiteDomainName(): string | undefined {\n    return this.websiteConfig?.websiteDomain;\n  }\n\n  public policy?: BucketPolicy;\n\n  /**\n   * Whether the bucket is public or not.\n   */\n  public public?: boolean;\n  private notifications?: BucketNotifications;\n  private readonly eventBridgeEnabled?: boolean;\n\n  constructor(scope: Construct, name: string, props: BucketProps = {}) {\n    super(scope, name, props);\n\n    this.node.addValidation({\n      validate: () => this.policy?.document.validateForResourcePolicy() ?? [],\n    });\n\n    const { websiteConfig, corsConfig, cloudfrontAccess } = props;\n    this._isWebsite = false;\n\n    if (props.bucketName && props.namePrefix) {\n      throw new Error(\n        \"Cannot specify both 'bucketName' and 'namePrefix'. Use only one.\",\n      );\n    }\n\n    let bucketPrefix: string | undefined;\n    if (!props.bucketName) {\n      // Bucket names must be lowercase and between 3 (min) and 63 (max) characters long.\n      bucketPrefix = this.stack.uniqueResourceNamePrefix(this, {\n        prefix: (props.namePrefix ?? this.gridUUID) + \"-\",\n        lowerCase: true,\n        allowedSpecialCharacters: \".-\",\n        maxLength: 63,\n      });\n    }\n\n    this.resource = new s3Bucket.S3Bucket(this, \"Resource\", {\n      bucket: props.bucketName,\n      forceDestroy: props.forceDestroy,\n      bucketPrefix,\n    });\n\n    this._versioned = props.versioned ?? false;\n    if (this._versioned) {\n      new s3BucketVersioning.S3BucketVersioningA(this, \"Versioning\", {\n        bucket: this.resource.bucket,\n        versioningConfiguration: {\n          status: this._versioned ? \"Enabled\" : \"Suspended\",\n        },\n      });\n    }\n    this.eventBridgeEnabled = props.eventBridgeEnabled;\n\n    if (props.sources) {\n      if (typeof props.sources === \"string\") {\n        this.addSource({ path: props.sources });\n      } else if (Array.isArray(props.sources)) {\n        for (const sourceProps of props.sources) {\n          if (typeof sourceProps === \"string\") {\n            this.addSource({ path: sourceProps });\n          } else {\n            this.addSource(sourceProps);\n          }\n        }\n      }\n    }\n\n    if (props.lifecycleRules) {\n      new s3BucketLifecycleConfiguration.S3BucketLifecycleConfiguration(\n        this,\n        \"LifeCycleConfig\",\n        {\n          bucket: this.resource.bucket,\n          rule: props.lifecycleRules.map((rule) => ({\n            ...rule,\n            status: rule.enabled ? \"Enabled\" : \"Disabled\",\n          })),\n        },\n      );\n    }\n\n    // Enforce AWS Foundational Security Best Practice\n    if (props.enforceSSL) {\n      this.enforceSSLStatement();\n      this.minimumTLSVersionStatement(props.minimumTLSVersion);\n    } else if (props.minimumTLSVersion) {\n      throw new Error(\n        \"'enforceSSL' must be enabled for 'minimumTLSVersion' to be applied\",\n      );\n    }\n\n    if (websiteConfig && websiteConfig.enabled) {\n      this._isWebsite = true;\n      this.websiteConfig =\n        new s3BucketWebsiteConfiguration.S3BucketWebsiteConfiguration(\n          this,\n          \"WebsiteConfig\",\n          {\n            bucket: this.resource.bucket,\n            ...websiteConfig,\n            indexDocument: websiteConfig?.indexDocument\n              ? {\n                  suffix: websiteConfig.indexDocument,\n                }\n              : {\n                  suffix: \"index.html\",\n                },\n          },\n        );\n    }\n\n    this.public = props.public ?? false;\n    if (this.public) {\n      // TODO: switch to Lazy config using \"grantPublicAccess\" mechanism instead?\n      // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-s3/lib/bucket.ts#L850\n      const ownershipControls =\n        new s3BucketOwnershipControls.S3BucketOwnershipControls(\n          this,\n          \"OwnershipControls\",\n          {\n            bucket: this.resource.bucket,\n            rule: {\n              objectOwnership: \"BucketOwnerPreferred\",\n            },\n          },\n        );\n      const publicAccessBlock =\n        new s3BucketPublicAccessBlock.S3BucketPublicAccessBlock(\n          this,\n          \"PublicAccessBlock\",\n          {\n            bucket: this.resource.bucket,\n            blockPublicAcls: false,\n            blockPublicPolicy: false,\n            ignorePublicAcls: false,\n            restrictPublicBuckets: false,\n          },\n        );\n      new s3BucketAcl.S3BucketAcl(this, \"PublicAcl\", {\n        bucket: this.resource.bucket,\n        acl: \"public-read\",\n        dependsOn: [ownershipControls, publicAccessBlock],\n      });\n      this.addToResourcePolicy(\n        new iam.PolicyStatement({\n          resources: [this.arnForObjects(\"*\")],\n          actions: [\"s3:GetObject\"],\n          principals: [new iam.AnyPrincipal()],\n        }),\n      );\n      // // policy depends on public access block?\n      // // is this needed?\n      // if (policyDependable && policyDependable instanceof Construct) {\n      //   policyDependable.node.addDependency(publicAccessBlock);\n      // }\n    }\n\n    if (corsConfig) {\n      this.corsConfig = new s3BucketCorsConfiguration.S3BucketCorsConfiguration(\n        this,\n        \"CorsConfig\",\n        {\n          bucket: this.resource.bucket,\n          ...corsConfig,\n        },\n      );\n    }\n\n    let originAccessIdentity: string | undefined;\n    if (cloudfrontAccess?.enabled) {\n      const oai = new OriginAccessIdentity(this, \"OriginAccessIdentity\", {\n        comment: `OAI for ${this.resource.bucket}`,\n      });\n      originAccessIdentity = oai.cloudFrontOriginAccessIdentityPath;\n      const resources = (cloudfrontAccess.keyPatterns ?? [\"*\"]).map(\n        (keyPattern) => this.arnForObjects(keyPattern),\n      );\n      this.addToResourcePolicy(\n        new iam.PolicyStatement({\n          resources,\n          actions: [\"s3:GetObject\"],\n          principals: [oai.grantPrincipal],\n        }),\n      );\n    }\n\n    if (this.eventBridgeEnabled) {\n      this.enableEventBridgeNotification();\n    }\n\n    //register outputs\n    this._outputs = {\n      name: this.resource.bucket,\n      arn: this.resource.arn,\n      domainName: this.resource.bucketDomainName,\n      regionalDomainName: this.resource.bucketRegionalDomainName,\n      websiteDomainName: this.websiteConfig?.websiteDomain,\n      websiteUrl: this.websiteConfig?.websiteEndpoint,\n      originAccessIdentity,\n    };\n  }\n\n  /**\n   * Adds a statement to the resource policy for a principal (i.e.\n   * account/role/service) to perform actions on this bucket and/or its\n   * contents. Use `bucketArn` and `arnForObjects(keys)` to obtain ARNs for\n   * this bucket or objects.\n   *\n   * Note that the policy statement may or may not be added to the policy.\n   * For example, when an `IBucket` is created from an existing bucket,\n   * it's not possible to tell whether the bucket already has a policy\n   * attached, let alone to re-use that policy to add more statements to it.\n   * So it's safest to do nothing in these cases.\n   *\n   * @param permission the policy statement to be added to the bucket's\n   * policy.\n   * @returns metadata about the execution of this method. If the policy\n   * was not added, the value of `statementAdded` will be `false`. You\n   * should always check this value to make sure that the operation was\n   * actually carried out. Otherwise, synthesis and deploy will terminate\n   * silently, which may be confusing.\n   */\n  public addToResourcePolicy(\n    permission: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    // TODO: re-add autoCreatePolicy option?\n    // ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-s3/lib/bucket.ts#L652\n    if (!this.policy) {\n      this.policy = new BucketPolicy(this, \"Policy\", { bucket: this });\n    }\n\n    if (this.policy) {\n      this.policy.document.addStatements(permission);\n      return { statementAdded: true, policyDependable: this.policy };\n    }\n\n    return { statementAdded: false };\n  }\n\n  /**\n   * Grant read permissions for this bucket and it's contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If encryption is used, permission to use the key to decrypt the contents\n   * of the bucket will also be granted to the same principal.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   */\n  public grantRead(identity: iam.IGrantable, objectsKeyPattern: any = \"*\") {\n    return this.grant(\n      identity,\n      perms.BUCKET_READ_ACTIONS,\n      perms.KEY_READ_ACTIONS,\n      this.resource.arn,\n      this.arnForObjects(objectsKeyPattern),\n    );\n  }\n\n  public grantWrite(\n    identity: iam.IGrantable,\n    objectsKeyPattern: any = \"*\",\n    allowedActionPatterns: string[] = [],\n  ) {\n    const grantedWriteActions =\n      allowedActionPatterns.length > 0\n        ? allowedActionPatterns\n        : this.writeActions;\n    return this.grant(\n      identity,\n      grantedWriteActions,\n      perms.KEY_WRITE_ACTIONS,\n      this.resource.arn,\n      this.arnForObjects(objectsKeyPattern),\n    );\n  }\n\n  /**\n   * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.\n   *\n   * If encryption is used, permission to use the key to encrypt the contents\n   * of written files will also be granted to the same principal.\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   */\n  public grantPut(identity: iam.IGrantable, objectsKeyPattern: any = \"*\") {\n    return this.grant(\n      identity,\n      perms.BUCKET_PUT_ACTIONS,\n      perms.KEY_WRITE_ACTIONS,\n      this.arnForObjects(objectsKeyPattern),\n    );\n  }\n\n  public grantPutAcl(\n    identity: iam.IGrantable,\n    objectsKeyPattern: string = \"*\",\n  ) {\n    return this.grant(\n      identity,\n      perms.BUCKET_PUT_ACL_ACTIONS,\n      [],\n      this.arnForObjects(objectsKeyPattern),\n    );\n  }\n\n  /**\n   * Grants s3:DeleteObject* permission to an IAM principal for objects\n   * in this bucket.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*'). Parameter type is `any` but `string` should be passed in.\n   */\n  public grantDelete(identity: iam.IGrantable, objectsKeyPattern: any = \"*\") {\n    return this.grant(\n      identity,\n      perms.BUCKET_DELETE_ACTIONS,\n      [],\n      this.arnForObjects(objectsKeyPattern),\n    );\n  }\n\n  public grantReadWrite(\n    identity: iam.IGrantable,\n    objectsKeyPattern: any = \"*\",\n  ) {\n    const bucketActions = perms.BUCKET_READ_ACTIONS.concat(this.writeActions);\n    // we need unique permissions because some permissions are common between read and write key actions\n    const keyActions = [\n      ...new Set([...perms.KEY_READ_ACTIONS, ...perms.KEY_WRITE_ACTIONS]),\n    ];\n\n    return this.grant(\n      identity,\n      bucketActions,\n      keyActions,\n      this.resource.arn,\n      this.arnForObjects(objectsKeyPattern),\n    );\n  }\n\n  // TODO: currently only supported through `props.public` in constructor\n  // /**\n  //  * Allows unrestricted access to objects from this bucket.\n  //  *\n  //  * IMPORTANT: This permission allows anyone to perform actions on S3 objects\n  //  * in this bucket, which is useful for when you configure your bucket as a\n  //  * website and want everyone to be able to read objects in the bucket without\n  //  * needing to authenticate.\n  //  *\n  //  * Without arguments, this method will grant read (\"s3:GetObject\") access to\n  //  * all objects (\"*\") in the bucket.\n  //  *\n  //  * The method returns the `iam.Grant` object, which can then be modified\n  //  * as needed. For example, you can add a condition that will restrict access only\n  //  * to an IPv4 range like this:\n  //  *\n  //  *     const grant = bucket.grantPublicAccess();\n  //  *     grant.resourceStatement!.addCondition(‘IpAddress’, { “aws:SourceIp”: “54.240.143.0/24” });\n  //  *\n  //  * Note that if this `IBucket` refers to an existing bucket, possibly not\n  //  * managed by CloudFormation, this method will have no effect, since it's\n  //  * impossible to modify the policy of an existing bucket.\n  //  *\n  //  * @param keyPrefix the prefix of S3 object keys (e.g. `home/*`). Default is \"*\".\n  //  * @param allowedActions the set of S3 actions to allow. Default is \"s3:GetObject\".\n  //  */\n  // public grantPublicAccess(keyPrefix = \"*\", ...allowedActions: string[]) {\n  //   if (!this.public) {\n  //     throw new Error(\"Cannot grant public access when 'public' is enabled\");\n  //   }\n  //   // TDOO: This should create publicAccess resource\n  //   allowedActions =\n  //     allowedActions.length > 0 ? allowedActions : [\"s3:GetObject\"];\n\n  //   return iam.Grant.addToPrincipalOrResource({\n  //     actions: allowedActions,\n  //     resourceArns: [this.arnForObjects(keyPrefix)],\n  //     grantee: new iam.AnyPrincipal(),\n  //     resource: this,\n  //   });\n  // }\n\n  /**\n   * Adds a bucket notification event destination.\n   *\n   * S3 Buckets only support a single notification configuration resource.\n   * Declaring multiple `aws_s3_bucket_notification` resources to the same\n   * S3 Bucket will cause a perpetual difference in configuration.\n   *\n   * Calling this function will overwrite any existing event notifications configured\n   * for the S3 bucket outside of this beacon.\n   *\n   * @param event The event to trigger the notification\n   * @param dest The notification destination (Lambda, SNS Topic or SQS Queue)\n   *\n   * @param filters S3 object key filter rules to determine which objects\n   * trigger this event. Each filter must include a `prefix` and/or `suffix`\n   * that will be matched against the s3 object key. Refer to the S3 Developer Guide\n   * for details about allowed filter rules.\n   *\n   * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html#notification-how-to-filtering\n   *\n   * @example\n   *\n   *    declare const myFunction: compute.Function;\n   *    const bucket = new storage.Bucket(this, 'MyBucket');\n   *    bucket.addEventNotification(s3.EventType.OBJECT_CREATED, new s3n.LambdaDestination(myFunction), {prefix: 'home/myusername/*'});\n   *\n   * @see\n   * https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html\n   */\n  public addEventNotification(\n    event: EventType,\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ) {\n    // TODO: This blocks adding notifications outside of the Stack owning the bucket...\n    // AWS-CDK works around this by using a CustomResource handler (Lambda function) which modifies\n    // the bucket policy in place (and CFN does not manage the actual bucket policy, so no tf state!)\n    this.withNotifications((notifications) =>\n      notifications.addNotification(event, dest, ...filters),\n    );\n  }\n\n  private withNotifications(cb: (notifications: BucketNotifications) => void) {\n    if (!this.notifications) {\n      this.notifications = new BucketNotifications(this, \"Notifications\", {\n        bucket: this,\n      });\n    }\n    cb(this.notifications);\n  }\n\n  /**\n   * Subscribes a destination to receive notifications when an object is\n   * created in the bucket. This is identical to calling\n   * `onEvent(EventType.OBJECT_CREATED)`.\n   *\n   * @param dest The notification destination (see onEvent)\n   * @param filters Filters (see onEvent)\n   */\n  public addObjectCreatedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ) {\n    return this.addEventNotification(\n      EventType.OBJECT_CREATED,\n      dest,\n      ...filters,\n    );\n  }\n\n  /**\n   * Subscribes a destination to receive notifications when an object is\n   * removed from the bucket. This is identical to calling\n   * `onEvent(EventType.OBJECT_REMOVED)`.\n   *\n   * @param dest The notification destination (see onEvent)\n   * @param filters Filters (see onEvent)\n   */\n  public addObjectRemovedNotification(\n    dest: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ) {\n    return this.addEventNotification(\n      EventType.OBJECT_REMOVED,\n      dest,\n      ...filters,\n    );\n  }\n\n  /**\n   * Enables event bridge notification, causing all events below to be sent to EventBridge:\n   *\n   * - Object Deleted (DeleteObject)\n   * - Object Deleted (Lifecycle expiration)\n   * - Object Restore Initiated\n   * - Object Restore Completed\n   * - Object Restore Expired\n   * - Object Storage Class Changed\n   * - Object Access Tier Changed\n   * - Object ACL Updated\n   * - Object Tags Added\n   * - Object Tags Deleted\n   */\n  public enableEventBridgeNotification() {\n    this.withNotifications((notifications) =>\n      notifications.enableEventBridgeNotification(),\n    );\n  }\n\n  private grant(\n    grantee: iam.IGrantable,\n    bucketActions: string[],\n    _keyActions: string[],\n    resourceArn: string,\n    ...otherResourceArns: string[]\n  ) {\n    const resources = [resourceArn, ...otherResourceArns];\n\n    const ret = iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions: bucketActions,\n      resourceArns: resources,\n      resource: this,\n    });\n\n    // TODO: re-add KMS support\n    // if (this.encryptionKey && keyActions && keyActions.length !== 0) {\n    //   this.encryptionKey.grant(grantee, ...keyActions);\n    // }\n\n    return ret;\n  }\n\n  private get writeActions(): string[] {\n    return [...perms.BUCKET_DELETE_ACTIONS, ...perms.BUCKET_PUT_ACTIONS];\n  }\n\n  /**\n   * Add a source to the bucket.\n   *\n   * @param props The properties of the source to add\n   */\n  public addSource(props: AddSourceOptions, sourceId?: string): string {\n    if (this.versioned) {\n      /**\n       * If you enable versioning on a bucket for the first time, it might take up to 15 minutes\n       * for the change to be fully propagated. We recommend that you wait for 15 minutes after\n       * enabling versioning before issuing write operations (PUT or DELETE) on objects in the bucket.\n       *\n       * Write operations issued before this conversion is complete may apply to unversioned objects.\n       */\n      if (!this.sourceSleep) {\n        this.sourceSleep = new sleep.Sleep(this, \"VersioningSleep\", {\n          createDuration: \"15m\",\n        });\n      }\n    }\n    const indexedSource = this.sources.find(\n      (sourceIndex) => sourceIndex.props === props,\n    );\n    if (indexedSource) {\n      if (sourceId && sourceId !== indexedSource.id) {\n        throw new Error(\n          `Duplicate bucket source for ${indexedSource.id} and ${sourceId}.`,\n        );\n      }\n      return indexedSource.id;\n    }\n    const nextIndex = this.sources.length;\n    const id = sourceId ?? `source-${nextIndex}`;\n    // ensure id (if provided) is unique within Bucket\n    if (this.sources.some((sourceIndex) => sourceIndex.id === id)) {\n      throw new Error(\n        `Duplicate source id ${id}. SourceIds must be unique within a Bucket.`,\n      );\n    }\n    this.sources.push({\n      props: {\n        ...props,\n        bucket: this,\n        dependsOn: this.sourceSleep ? [this.sourceSleep] : undefined,\n      },\n      id,\n    });\n    return id;\n  }\n\n  public isWebsite(): this is {\n    websiteDomainName: string;\n    bucketOutputs: { websiteUrl: string; websiteDomainName: string };\n  } {\n    return this._isWebsite;\n  }\n\n  /**\n   * The https URL of an S3 object. Specify `regional: false` at the options\n   * for non-regional URLs. For example:\n   *\n   * - `https://s3.us-west-1.amazonaws.com/onlybucket`\n   * - `https://s3.us-west-1.amazonaws.com/bucket/key`\n   * - `https://s3.cn-north-1.amazonaws.com.cn/china-bucket/mykey`\n   *\n   * @param key The S3 key of the object. If not specified, the URL of the\n   *      bucket is returned.\n   * @returns an ObjectS3Url token\n   */\n  public urlForObject(key?: string): string {\n    const stack = AwsStack.ofAwsConstruct(this);\n    const prefix = `https://s3.${this.env.region}.${stack.urlSuffix}/`;\n    if (typeof key !== \"string\") {\n      return this.urlJoin(prefix, this.bucketName);\n    }\n    return this.urlJoin(prefix, this.bucketName, key);\n  }\n\n  /**\n   * The S3 URL of an S3 object. For example:\n   *\n   * - `s3://onlybucket`\n   * - `s3://bucket/key`\n   *\n   * @param key The S3 key of the object. If not specified, the S3 URL of the\n   *      bucket is returned.\n   * @returns an ObjectS3Url token\n   */\n  public s3UrlForObject(key?: string): string {\n    const prefix = \"s3://\";\n    if (typeof key !== \"string\") {\n      return this.urlJoin(prefix, this.bucketName);\n    }\n    return this.urlJoin(prefix, this.bucketName, key);\n  }\n\n  /**\n   * Returns an ARN that represents all objects within the bucket that match\n   * the key pattern specified. To represent all keys, specify ``\"*\"``.\n   *\n   * If you need to specify a keyPattern with multiple components, concatenate them into a single string, e.g.:\n   *\n   *   arnForObjects(`home/${team}/${user}/*`)\n   *\n   */\n  public arnForObjects(keyPattern: string): string {\n    return `${this.resource.arn}/${keyPattern}`;\n  }\n\n  // https://github.com/aws/aws-cdk/blob/v2.140.0/packages/aws-cdk-lib/aws-s3/lib/bucket.ts#L953\n  private urlJoin(...components: string[]): string {\n    return components.reduce((result, component) => {\n      if (result.endsWith(\"/\")) {\n        result = result.slice(0, -1);\n      }\n      if (component.startsWith(\"/\")) {\n        component = component.slice(1);\n      }\n      return `${result}/${component}`;\n    });\n  }\n\n  /**\n   * Adds an iam statement to enforce SSL requests only.\n   */\n  private enforceSSLStatement() {\n    const statement = new iam.PolicyStatement({\n      actions: [\"s3:*\"],\n      condition: [\n        {\n          test: \"Bool\",\n          variable: \"aws:SecureTransport\",\n          values: [\"false\"],\n        },\n      ],\n      effect: iam.Effect.DENY,\n      resources: [this.resource.arn, this.arnForObjects(\"*\")],\n      principals: [new iam.AnyPrincipal()],\n    });\n    this.addToResourcePolicy(statement);\n  }\n\n  /**\n   * Adds an iam statement to allow requests with a minimum TLS\n   * version only.\n   */\n  private minimumTLSVersionStatement(minimumTLSVersion?: number) {\n    if (!minimumTLSVersion) return;\n    const statement = new iam.PolicyStatement({\n      actions: [\"s3:*\"],\n      condition: [\n        {\n          test: \"NumericLessThan\",\n          variable: \"s3:TlsVersion\",\n          values: [minimumTLSVersion.toString()],\n        },\n      ],\n      effect: iam.Effect.DENY,\n      resources: [this.resource.arn, this.arnForObjects(\"*\")],\n      principals: [new iam.AnyPrincipal()],\n    });\n    this.addToResourcePolicy(statement);\n  }\n\n  /**\n   * Adds resource to the Terraform JSON output at Synth time.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    /**\n     * A preparing resolve might add new resources to the stack\n     *\n     * should not add resources if no bucket sources are defined\n     */\n    if (Object.keys(this.sources).length === 0) {\n      return {};\n    }\n\n    for (const source of this.sources) {\n      // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag\n      // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48\n      if (this.node.tryFindChild(source.id)) continue; // ignore if already generated\n      new BucketSource(this, source.id, source.props);\n    }\n    return {};\n  }\n}\n\nexport interface AddSourceOptions {\n  /**\n   * Local path to the source files\n   */\n  readonly path: string;\n  /**\n   * Prefix to add to the uploaded objects\n   */\n  readonly prefix?: string;\n}\n\n// private interface to index Bucket sources by id\ninterface SourceIndex {\n  props: BucketSourceProps;\n  id: string;\n}\n\n/**\n * Storage class to move an object to\n */\nexport enum StorageClass {\n  /**\n   * Storage class for data that is accessed less frequently, but requires rapid\n   * access when needed.\n   *\n   * Has lower availability than Standard storage.\n   */\n  INFREQUENT_ACCESS = \"STANDARD_IA\",\n\n  /**\n   * Infrequent Access that's only stored in one availability zone.\n   *\n   * Has lower availability than standard InfrequentAccess.\n   */\n  ONE_ZONE_INFREQUENT_ACCESS = \"ONEZONE_IA\",\n\n  /**\n   * Storage class for long-term archival that can take between minutes and\n   * hours to access.\n   *\n   * Use for archives where portions of the data might need to be retrieved in\n   * minutes. Data stored in the GLACIER storage class has a minimum storage\n   * duration period of 90 days and can be accessed in as little as 1-5 minutes\n   * using expedited retrieval. If you delete an object before the 90-day\n   * minimum, you are charged for 90 days.\n   */\n  GLACIER = \"GLACIER\",\n\n  /**\n   * Storage class for long-term archival that can be accessed in a few milliseconds.\n   *\n   * It is ideal for data that is accessed once or twice per quarter, and\n   * that requires immediate access. Data stored in the GLACIER_IR storage class\n   * has a minimum storage duration period of 90 days and can be accessed in\n   * as milliseconds. If you delete an object before the 90-day minimum,\n   * you are charged for 90 days.\n   */\n  GLACIER_INSTANT_RETRIEVAL = \"GLACIER_IR\",\n\n  /**\n   * Use for archiving data that rarely needs to be accessed. Data stored in the\n   * DEEP_ARCHIVE storage class has a minimum storage duration period of 180\n   * days and a default retrieval time of 12 hours. If you delete an object\n   * before the 180-day minimum, you are charged for 180 days. For pricing\n   * information, see Amazon S3 Pricing.\n   */\n  DEEP_ARCHIVE = \"DEEP_ARCHIVE\",\n\n  /**\n   * The INTELLIGENT_TIERING storage class is designed to optimize storage costs\n   * by automatically moving data to the most cost-effective storage access\n   * tier, without performance impact or operational overhead.\n   * INTELLIGENT_TIERING delivers automatic cost savings by moving data on a\n   * granular object level between two access tiers, a frequent access tier and\n   * a lower-cost infrequent access tier, when access patterns change. The\n   * INTELLIGENT_TIERING storage class is ideal if you want to optimize storage\n   * costs automatically for long-lived data when access patterns are unknown or\n   * unpredictable.\n   */\n  INTELLIGENT_TIERING = \"INTELLIGENT_TIERING\",\n}\n\n/**\n * Notification event types.\n * @link https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-event-types-and-destinations.html#supported-notification-event-types\n */\nexport enum EventType {\n  /**\n   * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using\n   * these event types, you can enable notification when an object is created\n   * using a specific API, or you can use the s3:ObjectCreated:* event type to\n   * request notification regardless of the API that was used to create an\n   * object.\n   */\n  OBJECT_CREATED = \"s3:ObjectCreated:*\",\n\n  /**\n   * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using\n   * these event types, you can enable notification when an object is created\n   * using a specific API, or you can use the s3:ObjectCreated:* event type to\n   * request notification regardless of the API that was used to create an\n   * object.\n   */\n  OBJECT_CREATED_PUT = \"s3:ObjectCreated:Put\",\n\n  /**\n   * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using\n   * these event types, you can enable notification when an object is created\n   * using a specific API, or you can use the s3:ObjectCreated:* event type to\n   * request notification regardless of the API that was used to create an\n   * object.\n   */\n  OBJECT_CREATED_POST = \"s3:ObjectCreated:Post\",\n\n  /**\n   * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using\n   * these event types, you can enable notification when an object is created\n   * using a specific API, or you can use the s3:ObjectCreated:* event type to\n   * request notification regardless of the API that was used to create an\n   * object.\n   */\n  OBJECT_CREATED_COPY = \"s3:ObjectCreated:Copy\",\n\n  /**\n   * Amazon S3 APIs such as PUT, POST, and COPY can create an object. Using\n   * these event types, you can enable notification when an object is created\n   * using a specific API, or you can use the s3:ObjectCreated:* event type to\n   * request notification regardless of the API that was used to create an\n   * object.\n   */\n  OBJECT_CREATED_COMPLETE_MULTIPART_UPLOAD = \"s3:ObjectCreated:CompleteMultipartUpload\",\n\n  /**\n   * By using the ObjectRemoved event types, you can enable notification when\n   * an object or a batch of objects is removed from a bucket.\n   *\n   * You can request notification when an object is deleted or a versioned\n   * object is permanently deleted by using the s3:ObjectRemoved:Delete event\n   * type. Or you can request notification when a delete marker is created for\n   * a versioned object by using s3:ObjectRemoved:DeleteMarkerCreated. For\n   * information about deleting versioned objects, see Deleting Object\n   * Versions. You can also use a wildcard s3:ObjectRemoved:* to request\n   * notification anytime an object is deleted.\n   *\n   * You will not receive event notifications from automatic deletes from\n   * lifecycle policies or from failed operations.\n   */\n  OBJECT_REMOVED = \"s3:ObjectRemoved:*\",\n\n  /**\n   * By using the ObjectRemoved event types, you can enable notification when\n   * an object or a batch of objects is removed from a bucket.\n   *\n   * You can request notification when an object is deleted or a versioned\n   * object is permanently deleted by using the s3:ObjectRemoved:Delete event\n   * type. Or you can request notification when a delete marker is created for\n   * a versioned object by using s3:ObjectRemoved:DeleteMarkerCreated. For\n   * information about deleting versioned objects, see Deleting Object\n   * Versions. You can also use a wildcard s3:ObjectRemoved:* to request\n   * notification anytime an object is deleted.\n   *\n   * You will not receive event notifications from automatic deletes from\n   * lifecycle policies or from failed operations.\n   */\n  OBJECT_REMOVED_DELETE = \"s3:ObjectRemoved:Delete\",\n\n  /**\n   * By using the ObjectRemoved event types, you can enable notification when\n   * an object or a batch of objects is removed from a bucket.\n   *\n   * You can request notification when an object is deleted or a versioned\n   * object is permanently deleted by using the s3:ObjectRemoved:Delete event\n   * type. Or you can request notification when a delete marker is created for\n   * a versioned object by using s3:ObjectRemoved:DeleteMarkerCreated. For\n   * information about deleting versioned objects, see Deleting Object\n   * Versions. You can also use a wildcard s3:ObjectRemoved:* to request\n   * notification anytime an object is deleted.\n   *\n   * You will not receive event notifications from automatic deletes from\n   * lifecycle policies or from failed operations.\n   */\n  OBJECT_REMOVED_DELETE_MARKER_CREATED = \"s3:ObjectRemoved:DeleteMarkerCreated\",\n\n  /**\n   * Using restore object event types you can receive notifications for\n   * initiation and completion when restoring objects from the S3 Glacier\n   * storage class.\n   *\n   * You use s3:ObjectRestore:Post to request notification of object restoration\n   * initiation.\n   */\n  OBJECT_RESTORE_POST = \"s3:ObjectRestore:Post\",\n\n  /**\n   * Using restore object event types you can receive notifications for\n   * initiation and completion when restoring objects from the S3 Glacier\n   * storage class.\n   *\n   * You use s3:ObjectRestore:Completed to request notification of\n   * restoration completion.\n   */\n  OBJECT_RESTORE_COMPLETED = \"s3:ObjectRestore:Completed\",\n\n  /**\n   * Using restore object event types you can receive notifications for\n   * initiation and completion when restoring objects from the S3 Glacier\n   * storage class.\n   *\n   * You use s3:ObjectRestore:Delete to request notification of\n   * restoration completion.\n   */\n  OBJECT_RESTORE_DELETE = \"s3:ObjectRestore:Delete\",\n\n  /**\n   * You can use this event type to request Amazon S3 to send a notification\n   * message when Amazon S3 detects that an object of the RRS storage class is\n   * lost.\n   */\n  REDUCED_REDUNDANCY_LOST_OBJECT = \"s3:ReducedRedundancyLostObject\",\n\n  /**\n   * You receive this notification event when an object that was eligible for\n   * replication using Amazon S3 Replication Time Control failed to replicate.\n   */\n  REPLICATION_OPERATION_FAILED_REPLICATION = \"s3:Replication:OperationFailedReplication\",\n\n  /**\n   * You receive this notification event when an object that was eligible for\n   * replication using Amazon S3 Replication Time Control exceeded the 15-minute\n   * threshold for replication.\n   */\n  REPLICATION_OPERATION_MISSED_THRESHOLD = \"s3:Replication:OperationMissedThreshold\",\n\n  /**\n   * You receive this notification event for an object that was eligible for\n   * replication using the Amazon S3 Replication Time Control feature replicated\n   * after the 15-minute threshold.\n   */\n  REPLICATION_OPERATION_REPLICATED_AFTER_THRESHOLD = \"s3:Replication:OperationReplicatedAfterThreshold\",\n\n  /**\n   * You receive this notification event for an object that was eligible for\n   * replication using Amazon S3 Replication Time Control but is no longer tracked\n   * by replication metrics.\n   */\n  REPLICATION_OPERATION_NOT_TRACKED = \"s3:Replication:OperationNotTracked\",\n\n  /**\n   * By using the LifecycleExpiration event types, you can receive a notification\n   * when Amazon S3 deletes an object based on your S3 Lifecycle configuration.\n   */\n  LIFECYCLE_EXPIRATION = \"s3:LifecycleExpiration:*\",\n\n  /**\n   * The s3:LifecycleExpiration:Delete event type notifies you when an object\n   * in an unversioned bucket is deleted.\n   * It also notifies you when an object version is permanently deleted by an\n   * S3 Lifecycle configuration.\n   */\n  LIFECYCLE_EXPIRATION_DELETE = \"s3:LifecycleExpiration:Delete\",\n\n  /**\n   * The s3:LifecycleExpiration:DeleteMarkerCreated event type notifies you\n   * when S3 Lifecycle creates a delete marker when a current version of an\n   * object in versioned bucket is deleted.\n   */\n  LIFECYCLE_EXPIRATION_DELETE_MARKER_CREATED = \"s3:LifecycleExpiration:DeleteMarkerCreated\",\n\n  /**\n   * You receive this notification event when an object is transitioned to\n   * another Amazon S3 storage class by an S3 Lifecycle configuration.\n   */\n  LIFECYCLE_TRANSITION = \"s3:LifecycleTransition\",\n\n  /**\n   * You receive this notification event when an object within the\n   * S3 Intelligent-Tiering storage class moved to the Archive Access tier or\n   * Deep Archive Access tier.\n   */\n  INTELLIGENT_TIERING = \"s3:IntelligentTiering\",\n\n  /**\n   * By using the ObjectTagging event types, you can enable notification when\n   * an object tag is added or deleted from an object.\n   */\n  OBJECT_TAGGING = \"s3:ObjectTagging:*\",\n\n  /**\n   * The s3:ObjectTagging:Put event type notifies you when a tag is PUT on an\n   * object or an existing tag is updated.\n\n   */\n  OBJECT_TAGGING_PUT = \"s3:ObjectTagging:Put\",\n\n  /**\n   * The s3:ObjectTagging:Delete event type notifies you when a tag is removed\n   * from an object.\n   */\n  OBJECT_TAGGING_DELETE = \"s3:ObjectTagging:Delete\",\n\n  /**\n   * You receive this notification event when an ACL is PUT on an object or when\n   * an existing ACL is changed.\n   * An event is not generated when a request results in no change to an\n   * object’s ACL.\n   */\n  OBJECT_ACL_PUT = \"s3:ObjectAcl:Put\",\n}\n\nexport interface NotificationKeyFilter {\n  /**\n   * Unique identifier for each of the notification configurations.\n   */\n  readonly id?: string;\n  /**\n   * S3 keys must have the specified prefix.\n   */\n  readonly prefix?: string;\n\n  /**\n   * S3 keys must have the specified suffix.\n   */\n  readonly suffix?: string;\n}\n"]}