terraconstructs 0.0.8

package/lib/aws/edge/distribution.js

@@ -0,0 +1,444 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedResponseHeadersPolicy = exports.ManagedOriginRequestPolicy = exports.ManagedCachePolicy = exports.ViewerProtocolPolicy = exports.CachedMethods = exports.AllowedMethods = exports.SecurityPolicyProtocol = exports.SSLMethod = exports.PriceClass = exports.HttpVersion = exports.GeoRestrictionType = exports.Distribution = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+/**
+ * Amazon Cloudfront Distribution
+ */
+class Distribution extends aws_construct_1.AwsConstructBase {
+    get distributionOutputs() {
+        return this._outputs;
+    }
+    get outputs() {
+        return this.distributionOutputs;
+    }
+    get domainName() {
+        return this._domainName;
+    }
+    constructor(scope, name, props) {
+        super(scope, name, props);
+        this._origins = new Array();
+        this.additionalBehaviors = [];
+        if (props.certificate) {
+            const certificateRegion = aws_stack_1.AwsStack.ofAwsConstruct(this).splitArn(props.certificate.certificateArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME).region;
+            if (!cdktf_1.Token.isUnresolved(certificateRegion) &&
+                certificateRegion !== "us-east-1") {
+                throw new Error(`Distribution certificates must be in the us-east-1 region and the certificate you provided is in ${certificateRegion}.`);
+            }
+        }
+        this.certificate = props.certificate;
+        this.errorResponses = props.errorResponses ?? [];
+        const defaultOriginId = this.addOrigin(props.defaultBehavior.origin);
+        if (props.additionalBehaviors) {
+            Object.entries(props.additionalBehaviors).forEach(([pathPattern, behaviorOptions]) => {
+                this.addBehavior(pathPattern, behaviorOptions.origin, behaviorOptions);
+            });
+        }
+        // Comments have an undocumented limit of 128 characters
+        const trimmedComment = props.comment && props.comment.length > 128
+            ? `${props.comment.slice(0, 128 - 3)}...`
+            : props.comment;
+        this.resource = new provider_aws_1.cloudfrontDistribution.CloudfrontDistribution(this, "Resource", {
+            enabled: props.enabled ?? true,
+            origin: cdktf_1.Lazy.anyValue({
+                produce: () => this._origins.map((o) => 
+                // Lazy producers need additional xxxToTerraform wrap
+                provider_aws_1.cloudfrontDistribution.cloudfrontDistributionOriginToTerraform(o.origin.render(o.id))),
+            }),
+            defaultCacheBehavior: this._renderDefaultCacheBehavior({
+                pathPattern: "*", // ignored for Default Cache Behavior
+                targetOriginId: defaultOriginId,
+                ...props.defaultBehavior,
+            }),
+            orderedCacheBehavior: cdktf_1.Lazy.anyValue({
+                produce: () => this.additionalBehaviors.map((b) => 
+                // Lazy producers need additional xxxToTerraform wrap
+                provider_aws_1.cloudfrontDistribution.cloudfrontDistributionOrderedCacheBehaviorToTerraform({
+                    pathPattern: b.pathPattern,
+                    ...this._renderDefaultCacheBehavior(b),
+                })),
+            }, { omitEmptyArray: true }),
+            aliases: props.aliases,
+            comment: trimmedComment,
+            customErrorResponse: this.renderErrorResponses(),
+            defaultRootObject: props.defaultRootObject,
+            httpVersion: props.httpVersion ?? HttpVersion.HTTP2,
+            priceClass: props.priceClass ?? undefined,
+            restrictions: this.renderRestrictions(props.geoRestriction),
+            viewerCertificate: this.renderViewerCertificate(this.certificate, props.minimumProtocolVersion, props.sslSupportMethod),
+            waitForDeployment: props.waitForDeployment,
+        });
+        this._domainName = this.resource.domainName;
+        this.hostedZoneId = this.resource.hostedZoneId;
+        this._outputs = {
+            id: this.resource.id,
+            hostedZoneId: this.resource.hostedZoneId,
+            status: this.resource.status,
+            arn: this.resource.arn,
+            domainName: this._domainName,
+        };
+    }
+    /**
+     * Add an Origin to this Distribution.
+     *
+     * @param origin The Origin to add.
+     * @param originId An optional id to use for the Origin or one will be generated.
+     */
+    addOrigin(origin, originId) {
+        const indexedOrigin = this._origins.find((originIndex) => originIndex.origin === origin);
+        if (indexedOrigin) {
+            if (originId && originId !== indexedOrigin.id) {
+                throw new Error(`Duplicate origin for ${indexedOrigin.id} and ${originId}.`);
+            }
+            return indexedOrigin.id;
+        }
+        const nextIndex = this._origins.length;
+        const id = originId ?? `origin-${nextIndex}`;
+        // ensure id (if provided) is unique within Distribution
+        if (this._origins.some((originIndex) => originIndex.id === id)) {
+            throw new Error(`Duplicate origin id ${id}. OriginIds must be unique within a distribution`);
+        }
+        this._origins.push({ origin, id });
+        return id;
+    }
+    renderErrorResponses() {
+        if (this.errorResponses.length === 0) {
+            return undefined;
+        }
+        return this.errorResponses.map((errorConfig) => {
+            if (!errorConfig.responseHttpStatus &&
+                !errorConfig.ttl &&
+                !errorConfig.responsePagePath) {
+                throw new Error("A custom error response without either a 'responseHttpStatus', 'ttl' or 'responsePagePath' is not valid.");
+            }
+            return {
+                errorCachingMinTtl: errorConfig.ttl?.toSeconds(),
+                errorCode: errorConfig.httpStatus,
+                responseCode: errorConfig.responsePagePath
+                    ? (errorConfig.responseHttpStatus ?? errorConfig.httpStatus)
+                    : errorConfig.responseHttpStatus,
+                responsePagePath: errorConfig.responsePagePath,
+            };
+        });
+    }
+    /**
+     * Adds a new behavior to this distribution for the given pathPattern.
+     *
+     * @param pathPattern the path pattern (e.g., 'images/*') that specifies which requests to apply the behavior to.
+     * @param origin the origin to use for this behavior
+     * @param behaviorOptions the options for the behavior at this path.
+     */
+    addBehavior(pathPattern, origin, behaviorOptions = {}) {
+        if (pathPattern === "*") {
+            throw new Error("Only the default behavior can have a path pattern of '*'");
+        }
+        const targetOriginId = this.addOrigin(origin);
+        this.additionalBehaviors.push({
+            pathPattern,
+            origin,
+            targetOriginId,
+            ...behaviorOptions,
+        });
+    }
+    /**
+     * Creates and returns the Terraform representation of this behavior.
+     * This renders as a "CloudfrontDistributionDefaultCacheBehavior"
+     * regardless if this is a default cache behavior or not, as the two
+     * are identical except the `pathPattern` is omitted for the default
+     * cache behavior.
+     *
+     * @internal
+     */
+    _renderDefaultCacheBehavior(props) {
+        // TODO: should it be possible to leave cachePolicy be undefined?
+        const managedCachePolicyName = props.cachePolicy ?? ManagedCachePolicy.CACHING_OPTIMIZED;
+        const cachePolicy = this.dataLookup(managedCachePolicyName, provider_aws_1.dataAwsCloudfrontCachePolicy.DataAwsCloudfrontCachePolicy, { name: managedCachePolicyName });
+        const originRequestPolicy = this.dataLookup(props.originRequestPolicy, provider_aws_1.dataAwsCloudfrontOriginRequestPolicy.DataAwsCloudfrontOriginRequestPolicy, { name: props.originRequestPolicy });
+        const responseHeadersPolicy = this.dataLookup(props.responseHeadersPolicy, provider_aws_1.dataAwsCloudfrontResponseHeadersPolicy.DataAwsCloudfrontResponseHeadersPolicy, { name: props.responseHeadersPolicy });
+        return {
+            targetOriginId: props.targetOriginId,
+            allowedMethods: props.allowedMethods?.methods ?? AllowedMethods.ALLOW_GET_HEAD.methods,
+            cachedMethods: props.cachedMethods?.methods ?? CachedMethods.CACHE_GET_HEAD.methods,
+            cachePolicyId: cachePolicy?.id,
+            compress: props.compress ?? true,
+            originRequestPolicyId: originRequestPolicy?.id,
+            responseHeadersPolicyId: responseHeadersPolicy?.id,
+            smoothStreaming: props.smoothStreaming,
+            viewerProtocolPolicy: props.viewerProtocolPolicy ?? ViewerProtocolPolicy.ALLOW_ALL,
+        };
+    }
+    renderRestrictions(geoRestriction) {
+        return geoRestriction
+            ? {
+                geoRestriction: {
+                    restrictionType: geoRestriction.restrictionType,
+                    locations: geoRestriction.restrictionType !== GeoRestrictionType.NONE
+                        ? this.validateLocations(geoRestriction.locations)
+                        : undefined,
+                },
+            }
+            : {
+                geoRestriction: {
+                    restrictionType: GeoRestrictionType.NONE,
+                },
+            };
+    }
+    validateLocations(locations) {
+        const LOCATION_REGEX = /^[A-Z]{2}$/;
+        if (locations.length === 0) {
+            throw new Error("Should provide at least 1 location");
+        }
+        locations.forEach((location) => {
+            if (!LOCATION_REGEX.test(location)) {
+                // eslint-disable-next-line max-len
+                throw new Error(`Invalid location format for location: ${location}, location should be two-letter and uppercase country ISO 3166-1-alpha-2 code`);
+            }
+        });
+        return locations;
+    }
+    renderViewerCertificate(certificate, minimumProtocolVersionProp, sslSupportMethodProp) {
+        const minimumProtocolVersion = minimumProtocolVersionProp ?? SecurityPolicyProtocol.TLS_V1_2_2021;
+        const sslSupportMethod = sslSupportMethodProp ?? SSLMethod.SNI;
+        return {
+            ...(certificate
+                ? { acmCertificateArn: certificate.certificateArn }
+                : { cloudfrontDefaultCertificate: true }),
+            minimumProtocolVersion: minimumProtocolVersion,
+            sslSupportMethod: sslSupportMethod,
+        };
+    }
+    /**
+     * Conditionally lookup or create a child based on the id provided.
+     * If the id is undefined, it will return undefined.
+     *
+     * @param id the id of the child to lookup or create
+     * @param constructType the type of the child to create
+     * @param config the configuration to pass to the child
+     */
+    dataLookup(id, constructType, config) {
+        if (!id) {
+            return undefined;
+        }
+        let child = this.node.tryFindChild(id);
+        if (!child) {
+            child = new constructType(this, id, config);
+        }
+        return child;
+    }
+}
+exports.Distribution = Distribution;
+_a = JSII_RTTI_SYMBOL_1;
+Distribution[_a] = { fqn: "terraconstructs.aws.edge.Distribution", version: "0.0.8" };
+var GeoRestrictionType;
+(function (GeoRestrictionType) {
+    GeoRestrictionType["NONE"] = "none";
+    GeoRestrictionType["WHITELIST"] = "whitelist";
+    GeoRestrictionType["BLACKLIST"] = "blacklist";
+})(GeoRestrictionType || (exports.GeoRestrictionType = GeoRestrictionType = {}));
+// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-cloudfront/lib/distribution.ts
+/** Maximum HTTP version to support */
+var HttpVersion;
+(function (HttpVersion) {
+    /** HTTP 1.1 */
+    HttpVersion["HTTP1_1"] = "http1.1";
+    /** HTTP 2 */
+    HttpVersion["HTTP2"] = "http2";
+    /** HTTP 2 and HTTP 3 */
+    HttpVersion["HTTP2_AND_3"] = "http2and3";
+    /** HTTP 3 */
+    HttpVersion["HTTP3"] = "http3";
+})(HttpVersion || (exports.HttpVersion = HttpVersion = {}));
+/**
+ * The price class determines how many edge locations CloudFront will use for your distribution.
+ * See https://aws.amazon.com/cloudfront/pricing/ for full list of supported regions.
+ */
+var PriceClass;
+(function (PriceClass) {
+    /** USA, Canada, Europe, & Israel */
+    PriceClass["PRICE_CLASS_100"] = "PriceClass_100";
+    /** PRICE_CLASS_100 + South Africa, Kenya, Middle East, Japan, Singapore, South Korea, Taiwan, Hong Kong, & Philippines */
+    PriceClass["PRICE_CLASS_200"] = "PriceClass_200";
+    /** All locations */
+    PriceClass["PRICE_CLASS_ALL"] = "PriceClass_All";
+})(PriceClass || (exports.PriceClass = PriceClass = {}));
+/**
+ * The SSL method CloudFront will use for your distribution.
+ *
+ * Server Name Indication (SNI) - is an extension to the TLS computer networking protocol by which a client indicates
+ *  which hostname it is attempting to connect to at the start of the handshaking process. This allows a server to present
+ *  multiple certificates on the same IP address and TCP port number and hence allows multiple secure (HTTPS) websites
+ * (or any other service over TLS) to be served by the same IP address without requiring all those sites to use the same certificate.
+ *
+ * CloudFront can use SNI to host multiple distributions on the same IP - which a large majority of clients will support.
+ *
+ * If your clients cannot support SNI however - CloudFront can use dedicated IPs for your distribution - but there is a prorated monthly charge for
+ * using this feature. By default, we use SNI - but you can optionally enable dedicated IPs (VIP).
+ *
+ * See the CloudFront SSL for more details about pricing : https://aws.amazon.com/cloudfront/custom-ssl-domains/
+ *
+ */
+var SSLMethod;
+(function (SSLMethod) {
+    SSLMethod["SNI"] = "sni-only";
+    SSLMethod["VIP"] = "vip";
+})(SSLMethod || (exports.SSLMethod = SSLMethod = {}));
+/**
+ * The minimum version of the SSL protocol that you want CloudFront to use for HTTPS connections.
+ * CloudFront serves your objects only to browsers or devices that support at least the SSL version that you specify.
+ */
+var SecurityPolicyProtocol;
+(function (SecurityPolicyProtocol) {
+    SecurityPolicyProtocol["SSL_V3"] = "SSLv3";
+    SecurityPolicyProtocol["TLS_V1"] = "TLSv1";
+    SecurityPolicyProtocol["TLS_V1_2016"] = "TLSv1_2016";
+    SecurityPolicyProtocol["TLS_V1_1_2016"] = "TLSv1.1_2016";
+    SecurityPolicyProtocol["TLS_V1_2_2018"] = "TLSv1.2_2018";
+    SecurityPolicyProtocol["TLS_V1_2_2019"] = "TLSv1.2_2019";
+    SecurityPolicyProtocol["TLS_V1_2_2021"] = "TLSv1.2_2021";
+})(SecurityPolicyProtocol || (exports.SecurityPolicyProtocol = SecurityPolicyProtocol = {}));
+/**
+ * The HTTP methods that the Behavior will accept requests on.
+ */
+class AllowedMethods {
+    constructor(methods) {
+        this.methods = methods;
+    }
+}
+exports.AllowedMethods = AllowedMethods;
+_b = JSII_RTTI_SYMBOL_1;
+AllowedMethods[_b] = { fqn: "terraconstructs.aws.edge.AllowedMethods", version: "0.0.8" };
+/** HEAD and GET */
+AllowedMethods.ALLOW_GET_HEAD = new AllowedMethods(["GET", "HEAD"]);
+/** HEAD, GET, and OPTIONS */
+AllowedMethods.ALLOW_GET_HEAD_OPTIONS = new AllowedMethods([
+    "GET",
+    "HEAD",
+    "OPTIONS",
+]);
+/** All supported HTTP methods */
+AllowedMethods.ALLOW_ALL = new AllowedMethods([
+    "GET",
+    "HEAD",
+    "OPTIONS",
+    "PUT",
+    "PATCH",
+    "POST",
+    "DELETE",
+]);
+/**
+ * The HTTP methods that the Behavior will cache requests on.
+ */
+class CachedMethods {
+    constructor(methods) {
+        this.methods = methods;
+    }
+}
+exports.CachedMethods = CachedMethods;
+_c = JSII_RTTI_SYMBOL_1;
+CachedMethods[_c] = { fqn: "terraconstructs.aws.edge.CachedMethods", version: "0.0.8" };
+/** HEAD and GET */
+CachedMethods.CACHE_GET_HEAD = new CachedMethods(["GET", "HEAD"]);
+/** HEAD, GET, and OPTIONS */
+CachedMethods.CACHE_GET_HEAD_OPTIONS = new CachedMethods([
+    "GET",
+    "HEAD",
+    "OPTIONS",
+]);
+/**
+ * How HTTPs should be handled with your distribution.
+ */
+var ViewerProtocolPolicy;
+(function (ViewerProtocolPolicy) {
+    /** HTTPS only */
+    ViewerProtocolPolicy["HTTPS_ONLY"] = "https-only";
+    /** Will redirect HTTP requests to HTTPS */
+    ViewerProtocolPolicy["REDIRECT_TO_HTTPS"] = "redirect-to-https";
+    /** Both HTTP and HTTPS supported */
+    ViewerProtocolPolicy["ALLOW_ALL"] = "allow-all";
+})(ViewerProtocolPolicy || (exports.ViewerProtocolPolicy = ViewerProtocolPolicy = {}));
+/**
+ * CloudFront provides a set of managed cache policies that you can attach to any of your distribution's cache behaviors.
+ * With a managed cache policy, you don't need to write or maintain your own cache policy. The managed policies use settings that are optimized for specific use cases.
+ *
+ * @link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html
+ * @link https://registry.terraform.io/providers/hashicorp/aws/5.60.0/docs/data-sources/cloudfront_cache_policy#aws-managed-policies
+ */
+var ManagedCachePolicy;
+(function (ManagedCachePolicy) {
+    /**
+     * This policy is designed for use with an origin that is an AWS Amplify web app.
+     */
+    ManagedCachePolicy["AMPLIFY"] = "Managed-Amplify";
+    /**
+     * Optimize cache efficiency by minimizing the values that CloudFront includes in the cache key.
+     * Query strings and cookies are not included in the cache key, and only the normalized 'Accept-Encoding' header is included.
+     */
+    ManagedCachePolicy["CACHING_OPTIMIZED"] = "Managed-CachingOptimized";
+    /**
+     * Optimize cache efficiency by minimizing the values that CloudFront includes in the cache key.
+     * Query strings and cookies are not included in the cache key, and only the normalized 'Accept-Encoding' header is included.
+     * Disables cache compression.
+     */
+    ManagedCachePolicy["CACHING_OPTIMIZED_FOR_UNCOMPRESSED_OBJECTS"] = "Managed-CachingOptimizedForUncompressedObjects";
+    /** Disables caching. This policy is useful for dynamic content and for requests that are not cacheable. */
+    ManagedCachePolicy["CACHING_DISABLED"] = "Managed-CachingDisabled";
+    /** Designed for use with an origin that is an AWS Elemental MediaPackage endpoint. */
+    ManagedCachePolicy["ELEMENTAL_MEDIA_PACKAGE"] = "Managed-Elemental-MediaPackage";
+    /**
+     * Designed for use with an origin that returns Cache-Control HTTP response headers and does not serve different content based on values present in the query string.
+     */
+    ManagedCachePolicy["USE_ORIGIN_CACHE_CONTROL_HEADERS"] = "Managed-UseOriginCacheControlHeaders";
+    /**
+     * Designed for use with an origin that returns Cache-Control HTTP response headers and serves different content based on values present in the query string.
+     */
+    ManagedCachePolicy["USE_ORIGIN_CACHE_CONTROL_HEADERS_QUERY_STRINGS"] = "Managed-UseOriginCacheControlHeaders-QueryStrings";
+})(ManagedCachePolicy || (exports.ManagedCachePolicy = ManagedCachePolicy = {}));
+/**
+ * Origin Request Policy configuration.
+ *
+ * @link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html
+ * @link https://registry.terraform.io/providers/hashicorp/aws/5.60.0/docs/data-sources/cloudfront_origin_request_policy#aws-managed-policies
+ */
+var ManagedOriginRequestPolicy;
+(function (ManagedOriginRequestPolicy) {
+    /** This policy includes only the User-Agent and Referer headers. It doesn’t include any query strings or cookies. */
+    ManagedOriginRequestPolicy["USER_AGENT_REFERER_HEADERS"] = "Managed-UserAgentRefererHeaders";
+    /** This policy includes the header that enables cross-origin resource sharing (CORS) requests when the origin is a custom origin. */
+    ManagedOriginRequestPolicy["CORS_CUSTOM_ORIGIN"] = "Managed-CORS-CustomOrigin";
+    /** This policy includes the headers that enable cross-origin resource sharing (CORS) requests when the origin is an Amazon S3 bucket. */
+    ManagedOriginRequestPolicy["CORS_S3_ORIGIN"] = "Managed-CORS-S3Origin";
+    /** This policy includes all values (query strings, headers, and cookies) in the viewer request. */
+    ManagedOriginRequestPolicy["ALL_VIEWER"] = "Managed-AllViewer";
+    /** This policy is designed for use with an origin that is an AWS Elemental MediaTailor endpoint. */
+    ManagedOriginRequestPolicy["ELEMENTAL_MEDIA_TAILOR"] = "Managed-Elemental-MediaTailor-PersonalizedManifests";
+    /** This policy includes all values (headers, cookies, and query strings) in the viewer request, and all CloudFront headers that were released through June 2022 (CloudFront headers released after June 2022 are not included). */
+    ManagedOriginRequestPolicy["ALL_VIEWER_AND_CLOUDFRONT_2022"] = "Managed-AllViewerAndCloudFrontHeaders-2022-06";
+    /** This policy includes all values (query strings, and cookies) except the header in the viewer request. */
+    ManagedOriginRequestPolicy["ALL_VIEWER_EXCEPT_HOST_HEADER"] = "Managed-AllViewerExceptHostHeader";
+})(ManagedOriginRequestPolicy || (exports.ManagedOriginRequestPolicy = ManagedOriginRequestPolicy = {}));
+/**
+ * A Response Headers Policy configuration
+ *
+ * @link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html
+ * @link https://registry.terraform.io/providers/hashicorp/aws/5.60.0/docs/data-sources/cloudfront_response_headers_policy#aws-managed-policies
+ */
+var ManagedResponseHeadersPolicy;
+(function (ManagedResponseHeadersPolicy) {
+    /** Use this managed policy to allow simple CORS requests from any origin. */
+    ManagedResponseHeadersPolicy["CORS_ALLOW_ALL_ORIGINS"] = "Managed-SimpleCORS";
+    /** Use this managed policy to allow CORS requests from any origin, including preflight requests. */
+    ManagedResponseHeadersPolicy["CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT"] = "Managed-CORS-With-Preflight";
+    /** Use this managed policy to add a set of security headers to all responses that CloudFront sends to viewers. */
+    ManagedResponseHeadersPolicy["SECURITY_HEADERS"] = "Managed-SecurityHeadersPolicy";
+    /** Use this managed policy to allow simple CORS requests from any origin and add a set of security headers to all responses that CloudFront sends to viewers. */
+    ManagedResponseHeadersPolicy["CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS"] = "Managed-CORS-and-SecurityHeadersPolicy";
+    /** Use this managed policy to allow CORS requests from any origin, including preflight requests, and add a set of security headers to all responses that CloudFront sends to viewers. */
+    ManagedResponseHeadersPolicy["CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS"] = "Managed-CORS-with-preflight-and-SecurityHeadersPolicy";
+})(ManagedResponseHeadersPolicy || (exports.ManagedResponseHeadersPolicy = ManagedResponseHeadersPolicy = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distribution.js","sourceRoot":"","sources":["../../../src/aws/edge/distribution.ts"],"names":[],"mappings":";;;;;AAAA,sDAK6B;AAC7B,iCAAiD;AAIjD,gCAAmC;AACnC,oDAI0B;AAC1B,4CAAwC;AAmMxC;;GAEG;AACH,MAAa,YAAa,SAAQ,gCAAgB;IAKhD,IAAW,mBAAmB;QAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IACD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAUD,YAAY,KAAgB,EAAE,IAAY,EAAE,KAAwB;QAClE,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QARX,aAAQ,GAAG,IAAI,KAAK,EAAe,CAAC;QAEpC,wBAAmB,GAAoB,EAAE,CAAC;QAQzD,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YACtB,MAAM,iBAAiB,GAAG,oBAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,QAAQ,CAC9D,KAAK,CAAC,WAAW,CAAC,cAAc,EAChC,eAAS,CAAC,mBAAmB,CAC9B,CAAC,MAAM,CAAC;YACT,IACE,CAAC,aAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC;gBACtC,iBAAiB,KAAK,WAAW,EACjC,CAAC;gBACD,MAAM,IAAI,KAAK,CACb,oGAAoG,iBAAiB,GAAG,CACzH,CAAC;YACJ,CAAC;QACH,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,IAAI,EAAE,CAAC;QAEjD,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACrE,IAAI,KAAK,CAAC,mBAAmB,EAAE,CAAC;YAC9B,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,OAAO,CAC/C,CAAC,CAAC,WAAW,EAAE,eAAe,CAAC,EAAE,EAAE;gBACjC,IAAI,CAAC,WAAW,CACd,WAAW,EACX,eAAe,CAAC,MAAM,EACtB,eAAe,CAChB,CAAC;YACJ,CAAC,CACF,CAAC;QACJ,CAAC;QAED,wDAAwD;QACxD,MAAM,cAAc,GAClB,KAAK,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,GAAG;YACzC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,KAAK;YACzC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC;QAEpB,IAAI,CAAC,QAAQ,GAAG,IAAI,qCAAsB,CAAC,sBAAsB,CAC/D,IAAI,EACJ,UAAU,EACV;YACE,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,IAAI;YAC9B,MAAM,EAAE,YAAI,CAAC,QAAQ,CAAC;gBACpB,OAAO,EAAE,GAAG,EAAE,CACZ,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACtB,qDAAqD;gBACrD,qCAAsB,CAAC,uCAAuC,CAC5D,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CACtB,CACF;aACJ,CAAC;YACF,oBAAoB,EAAE,IAAI,CAAC,2BAA2B,CAAC;gBACrD,WAAW,EAAE,GAAG,EAAE,qCAAqC;gBACvD,cAAc,EAAE,eAAe;gBAC/B,GAAG,KAAK,CAAC,eAAe;aACzB,CAAC;YACF,oBAAoB,EAAE,YAAI,CAAC,QAAQ,CACjC;gBACE,OAAO,EAAE,GAAG,EAAE,CACZ,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACjC,qDAAqD;gBACrD,qCAAsB,CAAC,qDAAqD,CAC1E;oBACE,WAAW,EAAE,CAAC,CAAC,WAAW;oBAC1B,GAAG,IAAI,CAAC,2BAA2B,CAAC,CAAC,CAAC;iBACvC,CACF,CACF;aACJ,EACD,EAAE,cAAc,EAAE,IAAI,EAAE,CACzB;YACD,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,OAAO,EAAE,cAAc;YACvB,mBAAmB,EAAE,IAAI,CAAC,oBAAoB,EAAE;YAChD,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,WAAW,CAAC,KAAK;YACnD,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,SAAS;YACzC,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,cAAc,CAAC;YAC3D,iBAAiB,EAAE,IAAI,CAAC,uBAAuB,CAC7C,IAAI,CAAC,WAAW,EAChB,KAAK,CAAC,sBAAsB,EAC5B,KAAK,CAAC,gBAAgB,CACvB;YACD,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;SAC3C,CACF,CAAC;QAEF,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC5C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;QAC/C,IAAI,CAAC,QAAQ,GAAG;YACd,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE;YACpB,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY;YACxC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM;YAC5B,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG;YACtB,UAAU,EAAE,IAAI,CAAC,WAAW;SAC7B,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACI,SAAS,CAAC,MAAe,EAAE,QAAiB;QACjD,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CACtC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,MAAM,KAAK,MAAM,CAC/C,CAAC;QACF,IAAI,aAAa,EAAE,CAAC;YAClB,IAAI,QAAQ,IAAI,QAAQ,KAAK,aAAa,CAAC,EAAE,EAAE,CAAC;gBAC9C,MAAM,IAAI,KAAK,CACb,wBAAwB,aAAa,CAAC,EAAE,QAAQ,QAAQ,GAAG,CAC5D,CAAC;YACJ,CAAC;YACD,OAAO,aAAa,CAAC,EAAE,CAAC;QAC1B,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;QACvC,MAAM,EAAE,GAAG,QAAQ,IAAI,UAAU,SAAS,EAAE,CAAC;QAC7C,wDAAwD;QACxD,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;YAC/D,MAAM,IAAI,KAAK,CACb,uBAAuB,EAAE,kDAAkD,CAC5E,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;QACnC,OAAO,EAAE,CAAC;IACZ,CAAC;IAEO,oBAAoB;QAG1B,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE;YAC7C,IACE,CAAC,WAAW,CAAC,kBAAkB;gBAC/B,CAAC,WAAW,CAAC,GAAG;gBAChB,CAAC,WAAW,CAAC,gBAAgB,EAC7B,CAAC;gBACD,MAAM,IAAI,KAAK,CACb,0GAA0G,CAC3G,CAAC;YACJ,CAAC;YAED,OAAO;gBACL,kBAAkB,EAAE,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE;gBAChD,SAAS,EAAE,WAAW,CAAC,UAAU;gBACjC,YAAY,EAAE,WAAW,CAAC,gBAAgB;oBACxC,CAAC,CAAC,CAAC,WAAW,CAAC,kBAAkB,IAAI,WAAW,CAAC,UAAU,CAAC;oBAC5D,CAAC,CAAC,WAAW,CAAC,kBAAkB;gBAClC,gBAAgB,EAAE,WAAW,CAAC,gBAAgB;aAC/C,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAChB,WAAmB,EACnB,MAAe,EACf,kBAAsC,EAAE;QAExC,IAAI,WAAW,KAAK,GAAG,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,0DAA0D,CAC3D,CAAC;QACJ,CAAC;QACD,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAC9C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAC5B,WAAW;YACX,MAAM;YACN,cAAc;YACd,GAAG,eAAe;SACnB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACK,2BAA2B,CACjC,KAAoB;QAEpB,iEAAiE;QACjE,MAAM,sBAAsB,GAC1B,KAAK,CAAC,WAAW,IAAI,kBAAkB,CAAC,iBAAiB,CAAC;QAC5D,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CACjC,sBAAsB,EACtB,2CAA4B,CAAC,4BAA4B,EACzD,EAAE,IAAI,EAAE,sBAAsB,EAAE,CACjC,CAAC;QACF,MAAM,mBAAmB,GAAG,IAAI,CAAC,UAAU,CACzC,KAAK,CAAC,mBAAmB,EACzB,mDAAoC,CAAC,oCAAoC,EACzE,EAAE,IAAI,EAAE,KAAK,CAAC,mBAAmB,EAAE,CACpC,CAAC;QACF,MAAM,qBAAqB,GAAG,IAAI,CAAC,UAAU,CAC3C,KAAK,CAAC,qBAAqB,EAC3B,qDAAsC,CAAC,sCAAsC,EAC7E,EAAE,IAAI,EAAE,KAAK,CAAC,qBAAqB,EAAE,CACtC,CAAC;QACF,OAAO;YACL,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,cAAc,EACZ,KAAK,CAAC,cAAc,EAAE,OAAO,IAAI,cAAc,CAAC,cAAc,CAAC,OAAO;YACxE,aAAa,EACX,KAAK,CAAC,aAAa,EAAE,OAAO,IAAI,aAAa,CAAC,cAAc,CAAC,OAAO;YACtE,aAAa,EAAE,WAAW,EAAE,EAAE;YAC9B,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;YAChC,qBAAqB,EAAE,mBAAmB,EAAE,EAAE;YAC9C,uBAAuB,EAAE,qBAAqB,EAAE,EAAE;YAClD,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,oBAAoB,EAClB,KAAK,CAAC,oBAAoB,IAAI,oBAAoB,CAAC,SAAS;SAC/D,CAAC;IACJ,CAAC;IAEO,kBAAkB,CAAC,cAA+B;QACxD,OAAO,cAAc;YACnB,CAAC,CAAC;gBACE,cAAc,EAAE;oBACd,eAAe,EAAE,cAAc,CAAC,eAAe;oBAC/C,SAAS,EACP,cAAc,CAAC,eAAe,KAAK,kBAAkB,CAAC,IAAI;wBACxD,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,SAAS,CAAC;wBAClD,CAAC,CAAC,SAAS;iBAChB;aACF;YACH,CAAC,CAAC;gBACE,cAAc,EAAE;oBACd,eAAe,EAAE,kBAAkB,CAAC,IAAI;iBACzC;aACF,CAAC;IACR,CAAC;IAEO,iBAAiB,CAAC,SAAmB;QAC3C,MAAM,cAAc,GAAG,YAAY,CAAC;QACpC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QACD,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC7B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACnC,mCAAmC;gBACnC,MAAM,IAAI,KAAK,CACb,yCAAyC,QAAQ,+EAA+E,CACjI,CAAC;YACJ,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,uBAAuB,CAC7B,WAA0B,EAC1B,0BAAmD,EACnD,oBAAgC;QAEhC,MAAM,sBAAsB,GAC1B,0BAA0B,IAAI,sBAAsB,CAAC,aAAa,CAAC;QACrE,MAAM,gBAAgB,GAAG,oBAAoB,IAAI,SAAS,CAAC,GAAG,CAAC;QAE/D,OAAO;YACL,GAAG,CAAC,WAAW;gBACb,CAAC,CAAC,EAAE,iBAAiB,EAAE,WAAW,CAAC,cAAc,EAAE;gBACnD,CAAC,CAAC,EAAE,4BAA4B,EAAE,IAAI,EAAE,CAAC;YAC3C,sBAAsB,EAAE,sBAAsB;YAC9C,gBAAgB,EAAE,gBAAgB;SACnC,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACK,UAAU,CAChB,EAAsB,EACtB,aAIe,EACf,MAAY;QAEZ,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAA2B,CAAC;QACjE,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,IAAI,aAAa,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;;AA5UH,oCA6UC;;;AAOD,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,mCAAa,CAAA;IACb,6CAAuB,CAAA;IACvB,6CAAuB,CAAA;AACzB,CAAC,EAJW,kBAAkB,kCAAlB,kBAAkB,QAI7B;AAED,4GAA4G;AAE5G,sCAAsC;AACtC,IAAY,WASX;AATD,WAAY,WAAW;IACrB,eAAe;IACf,kCAAmB,CAAA;IACnB,aAAa;IACb,8BAAe,CAAA;IACf,wBAAwB;IACxB,wCAAyB,CAAA;IACzB,aAAa;IACb,8BAAe,CAAA;AACjB,CAAC,EATW,WAAW,2BAAX,WAAW,QAStB;AAED;;;GAGG;AACH,IAAY,UAOX;AAPD,WAAY,UAAU;IACpB,oCAAoC;IACpC,gDAAkC,CAAA;IAClC,0HAA0H;IAC1H,gDAAkC,CAAA;IAClC,oBAAoB;IACpB,gDAAkC,CAAA;AACpC,CAAC,EAPW,UAAU,0BAAV,UAAU,QAOrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,6BAAgB,CAAA;IAChB,wBAAW,CAAA;AACb,CAAC,EAHW,SAAS,yBAAT,SAAS,QAGpB;AAED;;;GAGG;AACH,IAAY,sBAQX;AARD,WAAY,sBAAsB;IAChC,0CAAgB,CAAA;IAChB,0CAAgB,CAAA;IAChB,oDAA0B,CAAA;IAC1B,wDAA8B,CAAA;IAC9B,wDAA8B,CAAA;IAC9B,wDAA8B,CAAA;IAC9B,wDAA8B,CAAA;AAChC,CAAC,EARW,sBAAsB,sCAAtB,sBAAsB,QAQjC;AA0ID;;GAEG;AACH,MAAa,cAAc;IAuBzB,YAAoB,OAAiB;QACnC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;;AAzBH,wCA0BC;;;AAzBC,mBAAmB;AACI,6BAAc,GAAG,IAAI,cAAc,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;AAC5E,6BAA6B;AACN,qCAAsB,GAAG,IAAI,cAAc,CAAC;IACjE,KAAK;IACL,MAAM;IACN,SAAS;CACV,CAAC,CAAC;AACH,iCAAiC;AACV,wBAAS,GAAG,IAAI,cAAc,CAAC;IACpD,KAAK;IACL,MAAM;IACN,SAAS;IACT,KAAK;IACL,OAAO;IACP,MAAM;IACN,QAAQ;CACT,CAAC,CAAC;AAUL;;GAEG;AACH,MAAa,aAAa;IAaxB,YAAoB,OAAiB;QACnC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;;AAfH,sCAgBC;;;AAfC,mBAAmB;AACI,4BAAc,GAAG,IAAI,aAAa,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;AAC3E,6BAA6B;AACN,oCAAsB,GAAG,IAAI,aAAa,CAAC;IAChE,KAAK;IACL,MAAM;IACN,SAAS;CACV,CAAC,CAAC;AAUL;;GAEG;AACH,IAAY,oBAOX;AAPD,WAAY,oBAAoB;IAC9B,iBAAiB;IACjB,iDAAyB,CAAA;IACzB,2CAA2C;IAC3C,+DAAuC,CAAA;IACvC,oCAAoC;IACpC,+CAAuB,CAAA;AACzB,CAAC,EAPW,oBAAoB,oCAApB,oBAAoB,QAO/B;AAED;;;;;;GAMG;AACH,IAAY,kBA4BX;AA5BD,WAAY,kBAAkB;IAC5B;;OAEG;IACH,iDAA2B,CAAA;IAC3B;;;OAGG;IACH,oEAA8C,CAAA;IAC9C;;;;OAIG;IACH,mHAA6F,CAAA;IAC7F,2GAA2G;IAC3G,kEAA4C,CAAA;IAC5C,sFAAsF;IACtF,gFAA0D,CAAA;IAC1D;;OAEG;IACH,+FAAyE,CAAA;IACzE;;OAEG;IACH,0HAAoG,CAAA;AACtG,CAAC,EA5BW,kBAAkB,kCAAlB,kBAAkB,QA4B7B;AAED;;;;;GAKG;AACH,IAAY,0BAeX;AAfD,WAAY,0BAA0B;IACpC,qHAAqH;IACrH,4FAA8D,CAAA;IAC9D,qIAAqI;IACrI,8EAAgD,CAAA;IAChD,yIAAyI;IACzI,sEAAwC,CAAA;IACxC,mGAAmG;IACnG,8DAAgC,CAAA;IAChC,oGAAoG;IACpG,4GAA8E,CAAA;IAC9E,mOAAmO;IACnO,8GAAgF,CAAA;IAChF,4GAA4G;IAC5G,iGAAmE,CAAA;AACrE,CAAC,EAfW,0BAA0B,0CAA1B,0BAA0B,QAerC;AAED;;;;;GAKG;AACH,IAAY,4BAWX;AAXD,WAAY,4BAA4B;IACtC,6EAA6E;IAC7E,6EAA6C,CAAA;IAC7C,oGAAoG;IACpG,qGAAqE,CAAA;IACrE,kHAAkH;IAClH,kFAAkD,CAAA;IAClD,iKAAiK;IACjK,sHAAsF,CAAA;IACtF,yLAAyL;IACzL,oJAAoH,CAAA;AACtH,CAAC,EAXW,4BAA4B,4CAA5B,4BAA4B,QAWvC","sourcesContent":["import {\n  cloudfrontDistribution,\n  dataAwsCloudfrontCachePolicy,\n  dataAwsCloudfrontOriginRequestPolicy,\n  dataAwsCloudfrontResponseHeadersPolicy,\n} from \"@cdktf/provider-aws\";\nimport { IResolvable, Token, Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ICertificate, IOrigin, FunctionAssociation } from \".\";\nimport { Duration } from \"../../duration\";\nimport { ArnFormat } from \"../arn\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\n\n// TODO: Re-add invalidation support\n// TODO: Re-add origin group (failover) support\n// TODO: Re-add key group support\n// TODO: Re-add WAF support\n// TODO: Re-add logging support\n// TODO: Re-add custom cache, originRequest, ResponseHeader policy support?\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface DistributionOutputs {\n  /**\n   * Identifier for the distribution. For example: `EDFDVBD632BHDS5`.\n   */\n  readonly id: string;\n\n  /**\n   * CloudFront Route 53 zone ID that can be used to\n   * route an Alias Resource Record Set to.\n   *\n   * This attribute is simply an alias for the zone ID\n   */\n  readonly hostedZoneId: string;\n\n  /**\n   * Current status of the distribution.\n   *\n   * `Deployed` if the distribution's information is fully propagated\n   * throughout the Amazon CloudFront system.\n   */\n  readonly status: string;\n\n  /**\n   * ARN for the distribution\n   */\n  readonly arn: string;\n\n  /**\n   * Domain name corresponding to the distribution.\n   *\n   * For example: `d604721fxaaqy9.cloudfront.net`\n   */\n  readonly domainName: string;\n}\n\n/**\n * Imported or created DNS zone attributes\n */\nexport interface IDistribution extends IAwsConstruct {\n  /** Strongly typed outputs\n   *\n   * @attribute\n   */\n  readonly distributionOutputs: DistributionOutputs;\n\n  /**\n   * Domain name corresponding to the distribution.\n   *\n   * @attribute\n   * For example: `d604721fxaaqy9.cloudfront.net`\n   */\n  readonly domainName: string;\n\n  /**\n   * CloudFront Route 53 zone ID that can be used to\n   * route an Alias Resource Record Set to.\n   *\n   * This attribute is simply an alias for the zone ID\n   */\n  readonly hostedZoneId: string;\n}\n\nexport interface DistributionProps extends AwsConstructProps {\n  /**\n   * Extra CNAMEs (alternate domain names), if any, for this distribution.\n   */\n  readonly aliases?: string[];\n\n  /**\n   * Whether the distribution is enabled to accept end user requests for content.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean | IResolvable;\n\n  /**\n   * If enabled, the resource will wait for the distribution status to change\n   * from InProgress to Deployed.\n   *\n   * Setting this tofalse will skip the process.\n   *\n   * @default: true.\n   */\n  readonly waitForDeployment?: boolean;\n\n  /**\n   * The default behavior for the distribution.\n   */\n  readonly defaultBehavior: BehaviorOptions;\n\n  /**\n   * Additional behaviors for the distribution, mapped by the pathPattern that specifies which requests to apply the behavior to.\n   *\n   * @default - no additional behaviors are added.\n   */\n  readonly additionalBehaviors?: Record<string, BehaviorOptions>;\n\n  /**\n   * A certificate to associate with the distribution. The certificate must be located in N. Virginia (us-east-1).\n   *\n   * @default - the CloudFront wildcard certificate (*.cloudfront.net) will be used.\n   */\n  readonly certificate?: ICertificate;\n\n  /**\n   * Any comments you want to include about the distribution.\n   *\n   * @default - no comment\n   */\n  readonly comment?: string;\n\n  /**\n   * The object that you want CloudFront to request from your origin (for example, index.html)\n   * when a viewer requests the root URL for your distribution. If no default object is set, the\n   * request goes to the origin's root (e.g., example.com/).\n   *\n   * @default - no default root object\n   */\n  readonly defaultRootObject?: string;\n\n  /**\n   * Controls the countries in which your content is distributed.\n   *\n   * @default - No geographic restrictions\n   */\n  readonly geoRestriction?: GeoRestriction;\n\n  /**\n   * Specify the maximum HTTP version that you want viewers to use to communicate with CloudFront.\n   *\n   * For viewers and CloudFront to use HTTP/2, viewers must support TLS 1.2 or later, and must support server name identification (SNI).\n   *\n   * @default HttpVersion.HTTP2\n   */\n  readonly httpVersion?: HttpVersion;\n\n  /**\n   * The price class that corresponds with the maximum price that you want to pay for CloudFront service.\n   * If you specify PriceClass_All, CloudFront responds to requests for your objects from all CloudFront edge locations.\n   * If you specify a price class other than PriceClass_All, CloudFront serves your objects from the CloudFront edge location\n   * that has the lowest latency among the edge locations in your price class.\n   *\n   * @default PriceClass.PRICE_CLASS_ALL\n   */\n  readonly priceClass?: PriceClass;\n\n  /**\n   * How CloudFront should handle requests that are not successful (e.g., PageNotFound).\n   *\n   * @default - No custom error responses.\n   */\n  readonly errorResponses?: ErrorResponse[];\n\n  /**\n   * The minimum version of the SSL protocol that you want CloudFront to use for HTTPS connections.\n   *\n   * CloudFront serves your objects only to browsers or devices that support at\n   * least the SSL version that you specify.\n   *\n   * @default - SecurityPolicyProtocol.TLS_V1_2_2021.\n   */\n  readonly minimumProtocolVersion?: SecurityPolicyProtocol;\n\n  /**\n   * The SSL method CloudFront will use for your distribution.\n   *\n   * Server Name Indication (SNI) - is an extension to the TLS computer networking protocol by which a client indicates\n   * which hostname it is attempting to connect to at the start of the handshaking process. This allows a server to present\n   * multiple certificates on the same IP address and TCP port number and hence allows multiple secure (HTTPS) websites\n   * (or any other service over TLS) to be served by the same IP address without requiring all those sites to use the same certificate.\n   *\n   * CloudFront can use SNI to host multiple distributions on the same IP - which a large majority of clients will support.\n   *\n   * If your clients cannot support SNI however - CloudFront can use dedicated IPs for your distribution - but there is a prorated monthly charge for\n   * using this feature. By default, we use SNI - but you can optionally enable dedicated IPs (VIP).\n   *\n   * See the CloudFront SSL for more details about pricing : https://aws.amazon.com/cloudfront/custom-ssl-domains/\n   *\n   * @default SSLMethod.SNI\n   */\n  readonly sslSupportMethod?: SSLMethod;\n}\n\n/**\n * Amazon Cloudfront Distribution\n */\nexport class Distribution extends AwsConstructBase implements IDistribution {\n  // TODO: Add static fromLookup?\n  private readonly resource: cloudfrontDistribution.CloudfrontDistribution;\n\n  private readonly _outputs: DistributionOutputs;\n  public get distributionOutputs(): DistributionOutputs {\n    return this._outputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this.distributionOutputs;\n  }\n  private readonly _domainName: string;\n  public get domainName(): string {\n    return this._domainName;\n  }\n  public readonly hostedZoneId: string;\n\n  private readonly _origins = new Array<OriginIndex>();\n\n  private readonly additionalBehaviors: CacheBehavior[] = [];\n\n  private readonly errorResponses: ErrorResponse[];\n  private readonly certificate?: ICertificate;\n\n  constructor(scope: Construct, name: string, props: DistributionProps) {\n    super(scope, name, props);\n\n    if (props.certificate) {\n      const certificateRegion = AwsStack.ofAwsConstruct(this).splitArn(\n        props.certificate.certificateArn,\n        ArnFormat.SLASH_RESOURCE_NAME,\n      ).region;\n      if (\n        !Token.isUnresolved(certificateRegion) &&\n        certificateRegion !== \"us-east-1\"\n      ) {\n        throw new Error(\n          `Distribution certificates must be in the us-east-1 region and the certificate you provided is in ${certificateRegion}.`,\n        );\n      }\n    }\n    this.certificate = props.certificate;\n    this.errorResponses = props.errorResponses ?? [];\n\n    const defaultOriginId = this.addOrigin(props.defaultBehavior.origin);\n    if (props.additionalBehaviors) {\n      Object.entries(props.additionalBehaviors).forEach(\n        ([pathPattern, behaviorOptions]) => {\n          this.addBehavior(\n            pathPattern,\n            behaviorOptions.origin,\n            behaviorOptions,\n          );\n        },\n      );\n    }\n\n    // Comments have an undocumented limit of 128 characters\n    const trimmedComment =\n      props.comment && props.comment.length > 128\n        ? `${props.comment.slice(0, 128 - 3)}...`\n        : props.comment;\n\n    this.resource = new cloudfrontDistribution.CloudfrontDistribution(\n      this,\n      \"Resource\",\n      {\n        enabled: props.enabled ?? true,\n        origin: Lazy.anyValue({\n          produce: () =>\n            this._origins.map((o) =>\n              // Lazy producers need additional xxxToTerraform wrap\n              cloudfrontDistribution.cloudfrontDistributionOriginToTerraform(\n                o.origin.render(o.id),\n              ),\n            ),\n        }),\n        defaultCacheBehavior: this._renderDefaultCacheBehavior({\n          pathPattern: \"*\", // ignored for Default Cache Behavior\n          targetOriginId: defaultOriginId,\n          ...props.defaultBehavior,\n        }),\n        orderedCacheBehavior: Lazy.anyValue(\n          {\n            produce: () =>\n              this.additionalBehaviors.map((b) =>\n                // Lazy producers need additional xxxToTerraform wrap\n                cloudfrontDistribution.cloudfrontDistributionOrderedCacheBehaviorToTerraform(\n                  {\n                    pathPattern: b.pathPattern,\n                    ...this._renderDefaultCacheBehavior(b),\n                  },\n                ),\n              ),\n          },\n          { omitEmptyArray: true },\n        ),\n        aliases: props.aliases,\n        comment: trimmedComment,\n        customErrorResponse: this.renderErrorResponses(),\n        defaultRootObject: props.defaultRootObject,\n        httpVersion: props.httpVersion ?? HttpVersion.HTTP2,\n        priceClass: props.priceClass ?? undefined,\n        restrictions: this.renderRestrictions(props.geoRestriction),\n        viewerCertificate: this.renderViewerCertificate(\n          this.certificate,\n          props.minimumProtocolVersion,\n          props.sslSupportMethod,\n        ),\n        waitForDeployment: props.waitForDeployment,\n      },\n    );\n\n    this._domainName = this.resource.domainName;\n    this.hostedZoneId = this.resource.hostedZoneId;\n    this._outputs = {\n      id: this.resource.id,\n      hostedZoneId: this.resource.hostedZoneId,\n      status: this.resource.status,\n      arn: this.resource.arn,\n      domainName: this._domainName,\n    };\n  }\n\n  /**\n   * Add an Origin to this Distribution.\n   *\n   * @param origin The Origin to add.\n   * @param originId An optional id to use for the Origin or one will be generated.\n   */\n  public addOrigin(origin: IOrigin, originId?: string): string {\n    const indexedOrigin = this._origins.find(\n      (originIndex) => originIndex.origin === origin,\n    );\n    if (indexedOrigin) {\n      if (originId && originId !== indexedOrigin.id) {\n        throw new Error(\n          `Duplicate origin for ${indexedOrigin.id} and ${originId}.`,\n        );\n      }\n      return indexedOrigin.id;\n    }\n    const nextIndex = this._origins.length;\n    const id = originId ?? `origin-${nextIndex}`;\n    // ensure id (if provided) is unique within Distribution\n    if (this._origins.some((originIndex) => originIndex.id === id)) {\n      throw new Error(\n        `Duplicate origin id ${id}. OriginIds must be unique within a distribution`,\n      );\n    }\n    this._origins.push({ origin, id });\n    return id;\n  }\n\n  private renderErrorResponses():\n    | cloudfrontDistribution.CloudfrontDistributionCustomErrorResponse[]\n    | undefined {\n    if (this.errorResponses.length === 0) {\n      return undefined;\n    }\n\n    return this.errorResponses.map((errorConfig) => {\n      if (\n        !errorConfig.responseHttpStatus &&\n        !errorConfig.ttl &&\n        !errorConfig.responsePagePath\n      ) {\n        throw new Error(\n          \"A custom error response without either a 'responseHttpStatus', 'ttl' or 'responsePagePath' is not valid.\",\n        );\n      }\n\n      return {\n        errorCachingMinTtl: errorConfig.ttl?.toSeconds(),\n        errorCode: errorConfig.httpStatus,\n        responseCode: errorConfig.responsePagePath\n          ? (errorConfig.responseHttpStatus ?? errorConfig.httpStatus)\n          : errorConfig.responseHttpStatus,\n        responsePagePath: errorConfig.responsePagePath,\n      };\n    });\n  }\n\n  /**\n   * Adds a new behavior to this distribution for the given pathPattern.\n   *\n   * @param pathPattern the path pattern (e.g., 'images/*') that specifies which requests to apply the behavior to.\n   * @param origin the origin to use for this behavior\n   * @param behaviorOptions the options for the behavior at this path.\n   */\n  public addBehavior(\n    pathPattern: string,\n    origin: IOrigin,\n    behaviorOptions: AddBehaviorOptions = {},\n  ) {\n    if (pathPattern === \"*\") {\n      throw new Error(\n        \"Only the default behavior can have a path pattern of '*'\",\n      );\n    }\n    const targetOriginId = this.addOrigin(origin);\n    this.additionalBehaviors.push({\n      pathPattern,\n      origin,\n      targetOriginId,\n      ...behaviorOptions,\n    });\n  }\n\n  /**\n   * Creates and returns the Terraform representation of this behavior.\n   * This renders as a \"CloudfrontDistributionDefaultCacheBehavior\"\n   * regardless if this is a default cache behavior or not, as the two\n   * are identical except the `pathPattern` is omitted for the default\n   * cache behavior.\n   *\n   * @internal\n   */\n  private _renderDefaultCacheBehavior(\n    props: CacheBehavior,\n  ): cloudfrontDistribution.CloudfrontDistributionDefaultCacheBehavior {\n    // TODO: should it be possible to leave cachePolicy be undefined?\n    const managedCachePolicyName =\n      props.cachePolicy ?? ManagedCachePolicy.CACHING_OPTIMIZED;\n    const cachePolicy = this.dataLookup(\n      managedCachePolicyName,\n      dataAwsCloudfrontCachePolicy.DataAwsCloudfrontCachePolicy,\n      { name: managedCachePolicyName },\n    );\n    const originRequestPolicy = this.dataLookup(\n      props.originRequestPolicy,\n      dataAwsCloudfrontOriginRequestPolicy.DataAwsCloudfrontOriginRequestPolicy,\n      { name: props.originRequestPolicy },\n    );\n    const responseHeadersPolicy = this.dataLookup(\n      props.responseHeadersPolicy,\n      dataAwsCloudfrontResponseHeadersPolicy.DataAwsCloudfrontResponseHeadersPolicy,\n      { name: props.responseHeadersPolicy },\n    );\n    return {\n      targetOriginId: props.targetOriginId,\n      allowedMethods:\n        props.allowedMethods?.methods ?? AllowedMethods.ALLOW_GET_HEAD.methods,\n      cachedMethods:\n        props.cachedMethods?.methods ?? CachedMethods.CACHE_GET_HEAD.methods,\n      cachePolicyId: cachePolicy?.id,\n      compress: props.compress ?? true,\n      originRequestPolicyId: originRequestPolicy?.id,\n      responseHeadersPolicyId: responseHeadersPolicy?.id,\n      smoothStreaming: props.smoothStreaming,\n      viewerProtocolPolicy:\n        props.viewerProtocolPolicy ?? ViewerProtocolPolicy.ALLOW_ALL,\n    };\n  }\n\n  private renderRestrictions(geoRestriction?: GeoRestriction) {\n    return geoRestriction\n      ? {\n          geoRestriction: {\n            restrictionType: geoRestriction.restrictionType,\n            locations:\n              geoRestriction.restrictionType !== GeoRestrictionType.NONE\n                ? this.validateLocations(geoRestriction.locations)\n                : undefined,\n          },\n        }\n      : {\n          geoRestriction: {\n            restrictionType: GeoRestrictionType.NONE,\n          },\n        };\n  }\n\n  private validateLocations(locations: string[]) {\n    const LOCATION_REGEX = /^[A-Z]{2}$/;\n    if (locations.length === 0) {\n      throw new Error(\"Should provide at least 1 location\");\n    }\n    locations.forEach((location) => {\n      if (!LOCATION_REGEX.test(location)) {\n        // eslint-disable-next-line max-len\n        throw new Error(\n          `Invalid location format for location: ${location}, location should be two-letter and uppercase country ISO 3166-1-alpha-2 code`,\n        );\n      }\n    });\n    return locations;\n  }\n\n  private renderViewerCertificate(\n    certificate?: ICertificate,\n    minimumProtocolVersionProp?: SecurityPolicyProtocol,\n    sslSupportMethodProp?: SSLMethod,\n  ): cloudfrontDistribution.CloudfrontDistributionViewerCertificate {\n    const minimumProtocolVersion =\n      minimumProtocolVersionProp ?? SecurityPolicyProtocol.TLS_V1_2_2021;\n    const sslSupportMethod = sslSupportMethodProp ?? SSLMethod.SNI;\n\n    return {\n      ...(certificate\n        ? { acmCertificateArn: certificate.certificateArn }\n        : { cloudfrontDefaultCertificate: true }),\n      minimumProtocolVersion: minimumProtocolVersion,\n      sslSupportMethod: sslSupportMethod,\n    };\n  }\n\n  /**\n   * Conditionally lookup or create a child based on the id provided.\n   * If the id is undefined, it will return undefined.\n   *\n   * @param id the id of the child to lookup or create\n   * @param constructType the type of the child to create\n   * @param config the configuration to pass to the child\n   */\n  private dataLookup<TConstruct extends Construct>(\n    id: string | undefined,\n    constructType: new (\n      scope: Construct,\n      idInput: string,\n      config: any,\n    ) => TConstruct,\n    config?: any,\n  ): TConstruct | undefined {\n    if (!id) {\n      return undefined;\n    }\n    let child = this.node.tryFindChild(id) as TConstruct | undefined;\n    if (!child) {\n      child = new constructType(this, id, config);\n    }\n    return child;\n  }\n}\n\nexport interface GeoRestriction {\n  readonly locations: string[];\n  readonly restrictionType: GeoRestrictionType;\n}\n\nexport enum GeoRestrictionType {\n  NONE = \"none\",\n  WHITELIST = \"whitelist\",\n  BLACKLIST = \"blacklist\",\n}\n\n// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-cloudfront/lib/distribution.ts\n\n/** Maximum HTTP version to support */\nexport enum HttpVersion {\n  /** HTTP 1.1 */\n  HTTP1_1 = \"http1.1\",\n  /** HTTP 2 */\n  HTTP2 = \"http2\",\n  /** HTTP 2 and HTTP 3 */\n  HTTP2_AND_3 = \"http2and3\",\n  /** HTTP 3 */\n  HTTP3 = \"http3\",\n}\n\n/**\n * The price class determines how many edge locations CloudFront will use for your distribution.\n * See https://aws.amazon.com/cloudfront/pricing/ for full list of supported regions.\n */\nexport enum PriceClass {\n  /** USA, Canada, Europe, & Israel */\n  PRICE_CLASS_100 = \"PriceClass_100\",\n  /** PRICE_CLASS_100 + South Africa, Kenya, Middle East, Japan, Singapore, South Korea, Taiwan, Hong Kong, & Philippines */\n  PRICE_CLASS_200 = \"PriceClass_200\",\n  /** All locations */\n  PRICE_CLASS_ALL = \"PriceClass_All\",\n}\n\n/**\n * The SSL method CloudFront will use for your distribution.\n *\n * Server Name Indication (SNI) - is an extension to the TLS computer networking protocol by which a client indicates\n *  which hostname it is attempting to connect to at the start of the handshaking process. This allows a server to present\n *  multiple certificates on the same IP address and TCP port number and hence allows multiple secure (HTTPS) websites\n * (or any other service over TLS) to be served by the same IP address without requiring all those sites to use the same certificate.\n *\n * CloudFront can use SNI to host multiple distributions on the same IP - which a large majority of clients will support.\n *\n * If your clients cannot support SNI however - CloudFront can use dedicated IPs for your distribution - but there is a prorated monthly charge for\n * using this feature. By default, we use SNI - but you can optionally enable dedicated IPs (VIP).\n *\n * See the CloudFront SSL for more details about pricing : https://aws.amazon.com/cloudfront/custom-ssl-domains/\n *\n */\nexport enum SSLMethod {\n  SNI = \"sni-only\",\n  VIP = \"vip\",\n}\n\n/**\n * The minimum version of the SSL protocol that you want CloudFront to use for HTTPS connections.\n * CloudFront serves your objects only to browsers or devices that support at least the SSL version that you specify.\n */\nexport enum SecurityPolicyProtocol {\n  SSL_V3 = \"SSLv3\",\n  TLS_V1 = \"TLSv1\",\n  TLS_V1_2016 = \"TLSv1_2016\",\n  TLS_V1_1_2016 = \"TLSv1.1_2016\",\n  TLS_V1_2_2018 = \"TLSv1.2_2018\",\n  TLS_V1_2_2019 = \"TLSv1.2_2019\",\n  TLS_V1_2_2021 = \"TLSv1.2_2021\",\n}\n\n/**\n * Options for configuring custom error responses.\n */\nexport interface ErrorResponse {\n  /**\n   * The minimum amount of time, in seconds, that you want CloudFront to cache the HTTP status code specified in ErrorCode.\n   *\n   * @default - the default caching TTL behavior applies\n   */\n  readonly ttl?: Duration;\n  /**\n   * The HTTP status code for which you want to specify a custom error page and/or a caching duration.\n   */\n  readonly httpStatus: number;\n  /**\n   * The HTTP status code that you want CloudFront to return to the viewer along with the custom error page.\n   *\n   * If you specify a value for `responseHttpStatus`, you must also specify a value for `responsePagePath`.\n   *\n   * @default - the error code will be returned as the response code.\n   */\n  readonly responseHttpStatus?: number;\n  /**\n   * The path to the custom error page that you want CloudFront to return to a viewer when your origin returns the\n   * `httpStatus`, for example, /4xx-errors/403-forbidden.html\n   *\n   * @default - the default CloudFront response is shown.\n   */\n  readonly responsePagePath?: string;\n}\n\n// private interface to keep track of CacheBehaviors\ninterface CacheBehavior extends BehaviorOptions {\n  /**\n   * The pattern (e.g., `images/*.jpg`) that specifies which requests to apply the behavior to.\n   * There must be exactly one behavior associated with each `Distribution` that has a path pattern\n   * of '*', which acts as the catch-all default behavior.\n   */\n  readonly pathPattern: string;\n\n  /**\n   * Value of ID for the origin that you want CloudFront to route requests to when a request matches\n   * the path pattern either for a cache behavior or for the default cache behavior.\n   */\n  readonly targetOriginId: string;\n}\n\n// private interface to index origins by id\ninterface OriginIndex {\n  origin: IOrigin;\n  id: string;\n}\n\n/**\n * Options for creating a new behavior.\n */\nexport interface BehaviorOptions extends AddBehaviorOptions {\n  /**\n   * The origin that you want CloudFront to route requests to when they match this behavior.\n   */\n  readonly origin: IOrigin;\n}\n\n/**\n * Options for adding a new behavior to a Distribution.\n */\nexport interface AddBehaviorOptions {\n  /**\n   * HTTP methods to allow for this behavior.\n   *\n   * @default AllowedMethods.ALLOW_GET_HEAD\n   */\n  readonly allowedMethods?: AllowedMethods;\n\n  /**\n   * HTTP methods to cache for this behavior.\n   *\n   * @default CachedMethods.CACHE_GET_HEAD\n   */\n  readonly cachedMethods?: CachedMethods;\n\n  /**\n   * The cache policy for this behavior. The cache policy determines what values are included in the cache key,\n   * and the time-to-live (TTL) values for the cache.\n   *\n   * @see https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/controlling-the-cache-key.html.\n   * @default ManagedCachePolicy.CACHING_OPTIMIZED\n   */\n  readonly cachePolicy?: ManagedCachePolicy; //TODO: support custom cache policies\n\n  /**\n   * Whether you want CloudFront to automatically compress certain files for this cache behavior.\n   * See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/ServingCompressedFiles.html#compressed-content-cloudfront-file-types\n   * for file types CloudFront will compress.\n   *\n   * @default true\n   */\n  readonly compress?: boolean;\n\n  /**\n   * The origin request policy for this behavior. The origin request policy determines which values (e.g., headers, cookies)\n   * are included in requests that CloudFront sends to the origin.\n   *\n   * @default - none\n   */\n  readonly originRequestPolicy?: ManagedOriginRequestPolicy; //TODO: support custom origin request policies\n\n  /**\n   * The response headers policy for this behavior. The response headers policy determines which headers are included in responses\n   *\n   * @default - none\n   */\n  readonly responseHeadersPolicy?: ManagedResponseHeadersPolicy;\n\n  /**\n   * Set this to true to indicate you want to distribute media files in the Microsoft Smooth Streaming format using this behavior.\n   *\n   * @default false\n   */\n  readonly smoothStreaming?: boolean;\n\n  /**\n   * The protocol that viewers can use to access the files controlled by this behavior.\n   *\n   * @default ViewerProtocolPolicy.ALLOW_ALL\n   */\n  readonly viewerProtocolPolicy?: ViewerProtocolPolicy;\n\n  /**\n   * The CloudFront functions to invoke before serving the contents.\n   *\n   * @default - no functions will be invoked\n   */\n  readonly functionAssociations?: FunctionAssociation[];\n}\n\n/**\n * The HTTP methods that the Behavior will accept requests on.\n */\nexport class AllowedMethods {\n  /** HEAD and GET */\n  public static readonly ALLOW_GET_HEAD = new AllowedMethods([\"GET\", \"HEAD\"]);\n  /** HEAD, GET, and OPTIONS */\n  public static readonly ALLOW_GET_HEAD_OPTIONS = new AllowedMethods([\n    \"GET\",\n    \"HEAD\",\n    \"OPTIONS\",\n  ]);\n  /** All supported HTTP methods */\n  public static readonly ALLOW_ALL = new AllowedMethods([\n    \"GET\",\n    \"HEAD\",\n    \"OPTIONS\",\n    \"PUT\",\n    \"PATCH\",\n    \"POST\",\n    \"DELETE\",\n  ]);\n\n  /** HTTP methods supported */\n  public readonly methods: string[];\n\n  private constructor(methods: string[]) {\n    this.methods = methods;\n  }\n}\n\n/**\n * The HTTP methods that the Behavior will cache requests on.\n */\nexport class CachedMethods {\n  /** HEAD and GET */\n  public static readonly CACHE_GET_HEAD = new CachedMethods([\"GET\", \"HEAD\"]);\n  /** HEAD, GET, and OPTIONS */\n  public static readonly CACHE_GET_HEAD_OPTIONS = new CachedMethods([\n    \"GET\",\n    \"HEAD\",\n    \"OPTIONS\",\n  ]);\n\n  /** HTTP methods supported */\n  public readonly methods: string[];\n\n  private constructor(methods: string[]) {\n    this.methods = methods;\n  }\n}\n\n/**\n * How HTTPs should be handled with your distribution.\n */\nexport enum ViewerProtocolPolicy {\n  /** HTTPS only */\n  HTTPS_ONLY = \"https-only\",\n  /** Will redirect HTTP requests to HTTPS */\n  REDIRECT_TO_HTTPS = \"redirect-to-https\",\n  /** Both HTTP and HTTPS supported */\n  ALLOW_ALL = \"allow-all\",\n}\n\n/**\n * CloudFront provides a set of managed cache policies that you can attach to any of your distribution's cache behaviors.\n * With a managed cache policy, you don't need to write or maintain your own cache policy. The managed policies use settings that are optimized for specific use cases.\n *\n * @link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-cache-policies.html\n * @link https://registry.terraform.io/providers/hashicorp/aws/5.60.0/docs/data-sources/cloudfront_cache_policy#aws-managed-policies\n */\nexport enum ManagedCachePolicy {\n  /**\n   * This policy is designed for use with an origin that is an AWS Amplify web app.\n   */\n  AMPLIFY = \"Managed-Amplify\",\n  /**\n   * Optimize cache efficiency by minimizing the values that CloudFront includes in the cache key.\n   * Query strings and cookies are not included in the cache key, and only the normalized 'Accept-Encoding' header is included.\n   */\n  CACHING_OPTIMIZED = \"Managed-CachingOptimized\",\n  /**\n   * Optimize cache efficiency by minimizing the values that CloudFront includes in the cache key.\n   * Query strings and cookies are not included in the cache key, and only the normalized 'Accept-Encoding' header is included.\n   * Disables cache compression.\n   */\n  CACHING_OPTIMIZED_FOR_UNCOMPRESSED_OBJECTS = \"Managed-CachingOptimizedForUncompressedObjects\",\n  /** Disables caching. This policy is useful for dynamic content and for requests that are not cacheable. */\n  CACHING_DISABLED = \"Managed-CachingDisabled\",\n  /** Designed for use with an origin that is an AWS Elemental MediaPackage endpoint. */\n  ELEMENTAL_MEDIA_PACKAGE = \"Managed-Elemental-MediaPackage\",\n  /**\n   * Designed for use with an origin that returns Cache-Control HTTP response headers and does not serve different content based on values present in the query string.\n   */\n  USE_ORIGIN_CACHE_CONTROL_HEADERS = \"Managed-UseOriginCacheControlHeaders\",\n  /**\n   * Designed for use with an origin that returns Cache-Control HTTP response headers and serves different content based on values present in the query string.\n   */\n  USE_ORIGIN_CACHE_CONTROL_HEADERS_QUERY_STRINGS = \"Managed-UseOriginCacheControlHeaders-QueryStrings\",\n}\n\n/**\n * Origin Request Policy configuration.\n *\n * @link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html\n * @link https://registry.terraform.io/providers/hashicorp/aws/5.60.0/docs/data-sources/cloudfront_origin_request_policy#aws-managed-policies\n */\nexport enum ManagedOriginRequestPolicy {\n  /** This policy includes only the User-Agent and Referer headers. It doesn’t include any query strings or cookies. */\n  USER_AGENT_REFERER_HEADERS = \"Managed-UserAgentRefererHeaders\",\n  /** This policy includes the header that enables cross-origin resource sharing (CORS) requests when the origin is a custom origin. */\n  CORS_CUSTOM_ORIGIN = \"Managed-CORS-CustomOrigin\",\n  /** This policy includes the headers that enable cross-origin resource sharing (CORS) requests when the origin is an Amazon S3 bucket. */\n  CORS_S3_ORIGIN = \"Managed-CORS-S3Origin\",\n  /** This policy includes all values (query strings, headers, and cookies) in the viewer request. */\n  ALL_VIEWER = \"Managed-AllViewer\",\n  /** This policy is designed for use with an origin that is an AWS Elemental MediaTailor endpoint. */\n  ELEMENTAL_MEDIA_TAILOR = \"Managed-Elemental-MediaTailor-PersonalizedManifests\",\n  /** This policy includes all values (headers, cookies, and query strings) in the viewer request, and all CloudFront headers that were released through June 2022 (CloudFront headers released after June 2022 are not included). */\n  ALL_VIEWER_AND_CLOUDFRONT_2022 = \"Managed-AllViewerAndCloudFrontHeaders-2022-06\",\n  /** This policy includes all values (query strings, and cookies) except the header in the viewer request. */\n  ALL_VIEWER_EXCEPT_HOST_HEADER = \"Managed-AllViewerExceptHostHeader\",\n}\n\n/**\n * A Response Headers Policy configuration\n *\n * @link https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-response-headers-policies.html\n * @link https://registry.terraform.io/providers/hashicorp/aws/5.60.0/docs/data-sources/cloudfront_response_headers_policy#aws-managed-policies\n */\nexport enum ManagedResponseHeadersPolicy {\n  /** Use this managed policy to allow simple CORS requests from any origin. */\n  CORS_ALLOW_ALL_ORIGINS = \"Managed-SimpleCORS\", //60669652-455b-4ae9-85a4-c4c02393f86c\n  /** Use this managed policy to allow CORS requests from any origin, including preflight requests. */\n  CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT = \"Managed-CORS-With-Preflight\", //5cc3b908-e619-4b99-88e5-2cf7f45965bd\n  /** Use this managed policy to add a set of security headers to all responses that CloudFront sends to viewers. */\n  SECURITY_HEADERS = \"Managed-SecurityHeadersPolicy\", //67f7725c-6f97-4210-82d7-5512b31e9d03\n  /** Use this managed policy to allow simple CORS requests from any origin and add a set of security headers to all responses that CloudFront sends to viewers. */\n  CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS = \"Managed-CORS-and-SecurityHeadersPolicy\", //e61eb60c-9c35-4d20-a928-2b84e02af89c\n  /** Use this managed policy to allow CORS requests from any origin, including preflight requests, and add a set of security headers to all responses that CloudFront sends to viewers. */\n  CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS = \"Managed-CORS-with-preflight-and-SecurityHeadersPolicy\", //eaab4381-ed33-4a86-88ca-d9558dc6cd63\n}\n"]}

package/lib/aws/edge/dns-alias-record-targets.d.ts

@@ -0,0 +1,29 @@
+import { route53Record } from "@cdktf/provider-aws";
+import { IRecordSet, IDnsZone, IDistribution } from ".";
+import { IBucket } from "../storage";
+/**
+ * Classes that are valid alias record targets, like CloudFront distributions and load
+ * balancers, should implement this interface.
+ */
+export interface IAliasRecordTarget {
+    /**
+     * Return hosted zone ID and DNS name, usable for Route53 alias targets
+     */
+    bind(record: IRecordSet, zone?: IDnsZone): route53Record.Route53RecordAlias;
+}
+/**
+ * Use a CloudFront Distribution as an alias record target
+ */
+export declare class DistributionTarget implements IAliasRecordTarget {
+    private readonly distribution;
+    constructor(distribution: IDistribution);
+    bind(_record: IRecordSet, _zone?: IDnsZone): route53Record.Route53RecordAlias;
+}
+/**
+ * Use Bucket as an alias record target
+ */
+export declare class BucketWebsiteTarget implements IAliasRecordTarget {
+    private readonly bucket;
+    constructor(bucket: IBucket);
+    bind(_record: IRecordSet, _zone?: IDnsZone): route53Record.Route53RecordAlias;
+}

package/lib/aws/edge/dns-alias-record-targets.js

@@ -0,0 +1,46 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketWebsiteTarget = exports.DistributionTarget = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Use a CloudFront Distribution as an alias record target
+ */
+class DistributionTarget {
+    constructor(distribution) {
+        this.distribution = distribution;
+    }
+    bind(_record, _zone) {
+        return {
+            zoneId: this.distribution.hostedZoneId,
+            name: this.distribution.domainName,
+            evaluateTargetHealth: false,
+        };
+    }
+}
+exports.DistributionTarget = DistributionTarget;
+_a = JSII_RTTI_SYMBOL_1;
+DistributionTarget[_a] = { fqn: "terraconstructs.aws.edge.DistributionTarget", version: "0.0.8" };
+/**
+ * Use Bucket as an alias record target
+ */
+class BucketWebsiteTarget {
+    constructor(bucket) {
+        this.bucket = bucket;
+    }
+    bind(_record, _zone) {
+        if (!this.bucket.isWebsite()) {
+            throw new Error("Cannot use a non-website bucket as an alias record target");
+        }
+        this.bucket.bucketOutputs.websiteDomainName;
+        return {
+            zoneId: this.bucket.hostedZoneId,
+            name: this.bucket.websiteDomainName,
+            evaluateTargetHealth: true,
+        };
+    }
+}
+exports.BucketWebsiteTarget = BucketWebsiteTarget;
+_b = JSII_RTTI_SYMBOL_1;
+BucketWebsiteTarget[_b] = { fqn: "terraconstructs.aws.edge.BucketWebsiteTarget", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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