terraconstructs 0.0.8 → 0.0.10

package/lib/aws/edge/response-headers-policy.d.ts

@@ -0,0 +1,374 @@
+import { cloudfrontResponseHeadersPolicy } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { Duration } from "../../duration";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+/**
+ * Represents a response headers policy.
+ */
+export interface IResponseHeadersPolicy {
+    /**
+     * The ID of the response headers policy
+     * @attribute
+     **/
+    readonly responseHeadersPolicyId: string;
+}
+/**
+ * Properties for creating a Response Headers Policy
+ */
+export interface ResponseHeadersPolicyProps extends AwsConstructProps {
+    /**
+     * A unique name to identify the response headers policy.
+     *
+     * @default - generated from the `id`
+     */
+    readonly responseHeadersPolicyName?: string;
+    /**
+     * A comment to describe the response headers policy.
+     *
+     * @default - no comment
+     */
+    readonly comment?: string;
+    /**
+     * A configuration for a set of HTTP response headers that are used for cross-origin resource sharing (CORS).
+     *
+     * @default - no cors behavior
+     */
+    readonly corsBehavior?: ResponseHeadersCorsBehavior;
+    /**
+     * A configuration for a set of custom HTTP response headers.
+     *
+     * @default - no custom headers behavior
+     */
+    readonly customHeadersBehavior?: ResponseCustomHeadersBehavior;
+    /**
+     * A configuration for a set of security-related HTTP response headers.
+     *
+     * @default - no security headers behavior
+     */
+    readonly securityHeadersBehavior?: ResponseSecurityHeadersBehavior;
+    /**
+     * A list of HTTP response headers that CloudFront removes from HTTP responses
+     * that it sends to viewers.
+     *
+     * @default - no headers are removed
+     */
+    readonly removeHeaders?: string[];
+    /**
+     * The percentage of responses that you want CloudFront to add the Server-Timing
+     * header to.
+     *
+     * @default - no Server-Timing header is added to HTTP responses
+     */
+    readonly serverTimingSamplingRate?: number;
+}
+/**
+ * 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/resources/cloudfront_response_headers_policy
+ */
+export declare class ResponseHeadersPolicy extends AwsConstructBase implements IResponseHeadersPolicy {
+    /**
+     * Import an existing Response Headers Policy from its ID.
+     */
+    static fromResponseHeadersPolicyId(scope: Construct, id: string, responseHeadersPolicyId: string): IResponseHeadersPolicy;
+    static fromManagedPolicyName(scope: Construct, id: string, managedResponseHeadersPolicyName: ManagedResponseHeadersPolicy): IResponseHeadersPolicy;
+    readonly resource: cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicy;
+    readonly responseHeadersPolicyId: string;
+    readonly outputs: Record<string, any>;
+    constructor(scope: Construct, id: string, props?: ResponseHeadersPolicyProps);
+    private _renderCorsConfig;
+    private _renderCustomHeadersConfig;
+    private _renderSecurityHeadersConfig;
+    private _renderRemoveHeadersConfig;
+    private _renderServerTimingHeadersConfig;
+}
+/**
+ * Configuration for a set of HTTP response headers that are used for cross-origin resource sharing (CORS).
+ * CloudFront adds these headers to HTTP responses that it sends for CORS requests that match a cache behavior
+ * associated with this response headers policy.
+ */
+export interface ResponseHeadersCorsBehavior {
+    /**
+     * A Boolean that CloudFront uses as the value for the Access-Control-Allow-Credentials HTTP response header.
+     */
+    readonly accessControlAllowCredentials: boolean;
+    /**
+     * A list of HTTP header names that CloudFront includes as values for the Access-Control-Allow-Headers HTTP response header.
+     * You can specify `['*']` to allow all headers.
+     */
+    readonly accessControlAllowHeaders: string[];
+    /**
+     * A list of HTTP methods that CloudFront includes as values for the Access-Control-Allow-Methods HTTP response header.
+     */
+    readonly accessControlAllowMethods: string[];
+    /**
+     * A list of origins (domain names) that CloudFront can use as the value for the Access-Control-Allow-Origin HTTP response header.
+     * You can specify `['*']` to allow all origins.
+     */
+    readonly accessControlAllowOrigins: string[];
+    /**
+     * A list of HTTP headers that CloudFront includes as values for the Access-Control-Expose-Headers HTTP response header.
+     * You can specify `['*']` to expose all headers.
+     *
+     * @default - no headers exposed
+     */
+    readonly accessControlExposeHeaders?: string[];
+    /**
+     * A number that CloudFront uses as the value for the Access-Control-Max-Age HTTP response header.
+     *
+     * @default - no max age
+     */
+    readonly accessControlMaxAge?: Duration;
+    /**
+     * A Boolean that determines whether CloudFront overrides HTTP response headers received from the origin with the ones specified in this response headers policy.
+     */
+    readonly originOverride: boolean;
+}
+/**
+ * Configuration for a set of HTTP response headers that are sent for requests that match a cache behavior
+ * that’s associated with this response headers policy.
+ */
+export interface ResponseCustomHeadersBehavior {
+    /**
+     * The list of HTTP response headers and their values.
+     */
+    readonly customHeaders: ResponseCustomHeader[];
+}
+/**
+ * An HTTP response header name and its value.
+ * CloudFront includes this header in HTTP responses that it sends for requests that match a cache behavior that’s associated with this response headers policy.
+ */
+export interface ResponseCustomHeader {
+    /**
+     * The HTTP response header name.
+     */
+    readonly header: string;
+    /**
+     * A Boolean that determines whether CloudFront overrides a response header with the same name
+     * received from the origin with the header specified here.
+     */
+    readonly override: boolean;
+    /**
+     * The value for the HTTP response header.
+     */
+    readonly value: string;
+}
+/**
+ * Configuration for a set of security-related HTTP response headers.
+ * CloudFront adds these headers to HTTP responses that it sends for requests that match a cache behavior
+ * associated with this response headers policy.
+ */
+export interface ResponseSecurityHeadersBehavior {
+    /**
+     * The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
+     *
+     * @default - no content security policy
+     */
+    readonly contentSecurityPolicy?: ResponseHeadersContentSecurityPolicy;
+    /**
+     * Determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff.
+     *
+     * @default - no content type options
+     */
+    readonly contentTypeOptions?: ResponseHeadersContentTypeOptions;
+    /**
+     * Determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value.
+     *
+     * @default - no frame options
+     */
+    readonly frameOptions?: ResponseHeadersFrameOptions;
+    /**
+     * Determines whether CloudFront includes the Referrer-Policy HTTP response header and the header’s value.
+     *
+     * @default - no referrer policy
+     */
+    readonly referrerPolicy?: ResponseHeadersReferrerPolicy;
+    /**
+     * Determines whether CloudFront includes the Strict-Transport-Security HTTP response header and the header’s value.
+     *
+     * @default - no strict transport security
+     */
+    readonly strictTransportSecurity?: ResponseHeadersStrictTransportSecurity;
+    /**
+     * Determines whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value.
+     *
+     * @default - no xss protection
+     */
+    readonly xssProtection?: ResponseHeadersXSSProtection;
+}
+/**
+ * The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
+ */
+export interface ResponseHeadersContentSecurityPolicy {
+    /**
+     * The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.
+     */
+    readonly contentSecurityPolicy: string;
+    /**
+     * A Boolean that determines whether CloudFront overrides the Content-Security-Policy HTTP response header
+     * received from the origin with the one specified in this response headers policy.
+     */
+    readonly override: boolean;
+}
+/**
+ * Determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff.
+ */
+export interface ResponseHeadersContentTypeOptions {
+    /**
+     * A Boolean that determines whether CloudFront overrides the X-Content-Type-Options HTTP response header
+     * received from the origin with the one specified in this response headers policy.
+     */
+    readonly override: boolean;
+}
+/**
+ * Determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value.
+ */
+export interface ResponseHeadersFrameOptions {
+    /**
+     * The value of the X-Frame-Options HTTP response header.
+     */
+    readonly frameOption: HeadersFrameOption;
+    /**
+     * A Boolean that determines whether CloudFront overrides the X-Frame-Options HTTP response header
+     * received from the origin with the one specified in this response headers policy.
+     */
+    readonly override: boolean;
+}
+/**
+ * Determines whether CloudFront includes the Referrer-Policy HTTP response header and the header’s value.
+ */
+export interface ResponseHeadersReferrerPolicy {
+    /**
+     * The value of the Referrer-Policy HTTP response header.
+     */
+    readonly referrerPolicy: HeadersReferrerPolicy;
+    /**
+     * A Boolean that determines whether CloudFront overrides the Referrer-Policy HTTP response header
+     * received from the origin with the one specified in this response headers policy.
+     */
+    readonly override: boolean;
+}
+/**
+ * Determines whether CloudFront includes the Strict-Transport-Security HTTP response header and the header’s value.
+ */
+export interface ResponseHeadersStrictTransportSecurity {
+    /**
+     * A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.
+     */
+    readonly accessControlMaxAge: Duration;
+    /**
+     * A Boolean that determines whether CloudFront includes the includeSubDomains directive in the Strict-Transport-Security HTTP response header.
+     *
+     * @default false
+     */
+    readonly includeSubdomains?: boolean;
+    /**
+     * A Boolean that determines whether CloudFront overrides the Strict-Transport-Security HTTP response header
+     * received from the origin with the one specified in this response headers policy.
+     */
+    readonly override: boolean;
+    /**
+     * A Boolean that determines whether CloudFront includes the preload directive in the Strict-Transport-Security HTTP response header.
+     *
+     * @default false
+     */
+    readonly preload?: boolean;
+}
+/**
+ * Determines whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value.
+ */
+export interface ResponseHeadersXSSProtection {
+    /**
+     * A Boolean that determines whether CloudFront includes the mode=block directive in the X-XSS-Protection header.
+     *
+     * @default false
+     */
+    readonly modeBlock?: boolean;
+    /**
+     * A Boolean that determines whether CloudFront overrides the X-XSS-Protection HTTP response header
+     * received from the origin with the one specified in this response headers policy.
+     */
+    readonly override: boolean;
+    /**
+     * A Boolean that determines the value of the X-XSS-Protection HTTP response header.
+     * When this setting is true, the value of the X-XSS-Protection header is 1.
+     * When this setting is false, the value of the X-XSS-Protection header is 0.
+     */
+    readonly protection: boolean;
+    /**
+     * A reporting URI, which CloudFront uses as the value of the report directive in the X-XSS-Protection header.
+     * You cannot specify a ReportUri when ModeBlock is true.
+     *
+     * @default - no report uri
+     */
+    readonly reportUri?: string;
+}
+/**
+ * Enum representing possible values of the X-Frame-Options HTTP response header.
+ */
+export declare enum HeadersFrameOption {
+    /**
+     * The page can only be displayed in a frame on the same origin as the page itself.
+     */
+    DENY = "DENY",
+    /**
+     * The page can only be displayed in a frame on the specified origin.
+     */
+    SAMEORIGIN = "SAMEORIGIN"
+}
+/**
+ * Enum representing possible values of the Referrer-Policy HTTP response header.
+ */
+export declare enum HeadersReferrerPolicy {
+    /**
+     * The referrer policy is not set.
+     */
+    NO_REFERRER = "no-referrer",
+    /**
+     * The referrer policy is no-referrer-when-downgrade.
+     */
+    NO_REFERRER_WHEN_DOWNGRADE = "no-referrer-when-downgrade",
+    /**
+     * The referrer policy is origin.
+     */
+    ORIGIN = "origin",
+    /**
+     * The referrer policy is origin-when-cross-origin.
+     */
+    ORIGIN_WHEN_CROSS_ORIGIN = "origin-when-cross-origin",
+    /**
+     * The referrer policy is same-origin.
+     */
+    SAME_ORIGIN = "same-origin",
+    /**
+     * The referrer policy is strict-origin.
+     */
+    STRICT_ORIGIN = "strict-origin",
+    /**
+     * The referrer policy is strict-origin-when-cross-origin.
+     */
+    STRICT_ORIGIN_WHEN_CROSS_ORIGIN = "strict-origin-when-cross-origin",
+    /**
+     * The referrer policy is unsafe-url.
+     */
+    UNSAFE_URL = "unsafe-url"
+}
+/**
+ * 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
+ */
+export declare enum ManagedResponseHeadersPolicy {
+    /** Use this managed policy to allow simple CORS requests from any origin. */
+    CORS_ALLOW_ALL_ORIGINS = "Managed-SimpleCORS",//60669652-455b-4ae9-85a4-c4c02393f86c
+    /** Use this managed policy to allow CORS requests from any origin, including preflight requests. */
+    CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT = "Managed-CORS-With-Preflight",//5cc3b908-e619-4b99-88e5-2cf7f45965bd
+    /** Use this managed policy to add a set of security headers to all responses that CloudFront sends to viewers. */
+    SECURITY_HEADERS = "Managed-SecurityHeadersPolicy",//67f7725c-6f97-4210-82d7-5512b31e9d03
+    /** 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. */
+    CORS_ALLOW_ALL_ORIGINS_AND_SECURITY_HEADERS = "Managed-CORS-and-SecurityHeadersPolicy",//e61eb60c-9c35-4d20-a928-2b84e02af89c
+    /** 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. */
+    CORS_ALLOW_ALL_ORIGINS_WITH_PREFLIGHT_AND_SECURITY_HEADERS = "Managed-CORS-with-preflight-and-SecurityHeadersPolicy"
+}

package/lib/aws/edge/response-headers-policy.js

@@ -0,0 +1,220 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedResponseHeadersPolicy = exports.HeadersReferrerPolicy = exports.HeadersFrameOption = exports.ResponseHeadersPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/0f077c0a6adc1e5258d073f6de232d09cbb7ae54/packages/aws-cdk-lib/aws-cloudfront/lib/response-headers-policy.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * 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/resources/cloudfront_response_headers_policy
+ */
+class ResponseHeadersPolicy extends aws_construct_1.AwsConstructBase {
+    /**
+     * Import an existing Response Headers Policy from its ID.
+     */
+    static fromResponseHeadersPolicyId(scope, id, responseHeadersPolicyId) {
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.outputs = {};
+                this.responseHeadersPolicyId = responseHeadersPolicyId;
+            }
+        }
+        return new Import(scope, id);
+    }
+    static fromManagedPolicyName(scope, id, managedResponseHeadersPolicyName) {
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(scope, id);
+                this.outputs = {};
+                this.resource =
+                    new provider_aws_1.dataAwsCloudfrontResponseHeadersPolicy.DataAwsCloudfrontResponseHeadersPolicy(this, "Resource", {
+                        name: managedResponseHeadersPolicyName,
+                    });
+                this.responseHeadersPolicyId = this.resource.id;
+            }
+        }
+        return new Import();
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.outputs = {};
+        const responseHeadersPolicyName = props.responseHeadersPolicyName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+                maxLength: 128,
+            });
+        this.resource =
+            new provider_aws_1.cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicy(this, "Resource", {
+                name: responseHeadersPolicyName,
+                comment: props.comment,
+                corsConfig: props.corsBehavior
+                    ? this._renderCorsConfig(props.corsBehavior)
+                    : undefined,
+                customHeadersConfig: props.customHeadersBehavior
+                    ? this._renderCustomHeadersConfig(props.customHeadersBehavior)
+                    : undefined,
+                securityHeadersConfig: props.securityHeadersBehavior
+                    ? this._renderSecurityHeadersConfig(props.securityHeadersBehavior)
+                    : undefined,
+                removeHeadersConfig: props.removeHeaders
+                    ? this._renderRemoveHeadersConfig(props.removeHeaders)
+                    : undefined,
+                serverTimingHeadersConfig: props.serverTimingSamplingRate
+                    ? this._renderServerTimingHeadersConfig(props.serverTimingSamplingRate)
+                    : undefined,
+            });
+        this.responseHeadersPolicyId = this.resource.id;
+    }
+    _renderCorsConfig(behavior) {
+        return {
+            accessControlAllowCredentials: behavior.accessControlAllowCredentials,
+            accessControlAllowHeaders: { items: behavior.accessControlAllowHeaders },
+            accessControlAllowMethods: { items: behavior.accessControlAllowMethods },
+            accessControlAllowOrigins: { items: behavior.accessControlAllowOrigins },
+            accessControlExposeHeaders: behavior.accessControlExposeHeaders
+                ? { items: behavior.accessControlExposeHeaders }
+                : undefined,
+            accessControlMaxAgeSec: behavior.accessControlMaxAge
+                ? behavior.accessControlMaxAge.toSeconds()
+                : undefined,
+            originOverride: behavior.originOverride,
+        };
+    }
+    _renderCustomHeadersConfig(behavior) {
+        return {
+            items: behavior.customHeaders,
+        };
+    }
+    _renderSecurityHeadersConfig(behavior) {
+        return {
+            contentSecurityPolicy: behavior.contentSecurityPolicy,
+            contentTypeOptions: behavior.contentTypeOptions,
+            frameOptions: behavior.frameOptions,
+            referrerPolicy: behavior.referrerPolicy,
+            strictTransportSecurity: behavior.strictTransportSecurity
+                ? {
+                    ...behavior.strictTransportSecurity,
+                    accessControlMaxAgeSec: behavior.strictTransportSecurity.accessControlMaxAge.toSeconds(),
+                }
+                : undefined,
+            xssProtection: behavior.xssProtection,
+        };
+    }
+    _renderRemoveHeadersConfig(headers) {
+        const readonlyHeaders = [
+            "content-encoding",
+            "content-length",
+            "transfer-encoding",
+            "warning",
+            "via",
+        ];
+        return {
+            items: headers.map((header) => {
+                if (!cdktf_1.Token.isUnresolved(header) &&
+                    readonlyHeaders.includes(header.toLowerCase())) {
+                    throw new Error(`Cannot remove read-only header ${header}`);
+                }
+                return { header };
+            }),
+        };
+    }
+    _renderServerTimingHeadersConfig(samplingRate) {
+        if (!cdktf_1.Token.isUnresolved(samplingRate)) {
+            if (samplingRate < 0 || samplingRate > 100) {
+                throw new Error(`Sampling rate must be between 0 and 100 (inclusive), received ${samplingRate}`);
+            }
+            if (!hasMaxDecimalPlaces(samplingRate, 4)) {
+                throw new Error(`Sampling rate can have up to four decimal places, received ${samplingRate}`);
+            }
+        }
+        return {
+            enabled: true,
+            samplingRate,
+        };
+    }
+}
+exports.ResponseHeadersPolicy = ResponseHeadersPolicy;
+_a = JSII_RTTI_SYMBOL_1;
+ResponseHeadersPolicy[_a] = { fqn: "terraconstructs.aws.edge.ResponseHeadersPolicy", version: "0.0.10" };
+/**
+ * Enum representing possible values of the X-Frame-Options HTTP response header.
+ */
+var HeadersFrameOption;
+(function (HeadersFrameOption) {
+    /**
+     * The page can only be displayed in a frame on the same origin as the page itself.
+     */
+    HeadersFrameOption["DENY"] = "DENY";
+    /**
+     * The page can only be displayed in a frame on the specified origin.
+     */
+    HeadersFrameOption["SAMEORIGIN"] = "SAMEORIGIN";
+})(HeadersFrameOption || (exports.HeadersFrameOption = HeadersFrameOption = {}));
+/**
+ * Enum representing possible values of the Referrer-Policy HTTP response header.
+ */
+var HeadersReferrerPolicy;
+(function (HeadersReferrerPolicy) {
+    /**
+     * The referrer policy is not set.
+     */
+    HeadersReferrerPolicy["NO_REFERRER"] = "no-referrer";
+    /**
+     * The referrer policy is no-referrer-when-downgrade.
+     */
+    HeadersReferrerPolicy["NO_REFERRER_WHEN_DOWNGRADE"] = "no-referrer-when-downgrade";
+    /**
+     * The referrer policy is origin.
+     */
+    HeadersReferrerPolicy["ORIGIN"] = "origin";
+    /**
+     * The referrer policy is origin-when-cross-origin.
+     */
+    HeadersReferrerPolicy["ORIGIN_WHEN_CROSS_ORIGIN"] = "origin-when-cross-origin";
+    /**
+     * The referrer policy is same-origin.
+     */
+    HeadersReferrerPolicy["SAME_ORIGIN"] = "same-origin";
+    /**
+     * The referrer policy is strict-origin.
+     */
+    HeadersReferrerPolicy["STRICT_ORIGIN"] = "strict-origin";
+    /**
+     * The referrer policy is strict-origin-when-cross-origin.
+     */
+    HeadersReferrerPolicy["STRICT_ORIGIN_WHEN_CROSS_ORIGIN"] = "strict-origin-when-cross-origin";
+    /**
+     * The referrer policy is unsafe-url.
+     */
+    HeadersReferrerPolicy["UNSAFE_URL"] = "unsafe-url";
+})(HeadersReferrerPolicy || (exports.HeadersReferrerPolicy = HeadersReferrerPolicy = {}));
+function hasMaxDecimalPlaces(num, decimals) {
+    const parts = num.toString().split(".");
+    return parts.length === 1 || parts[1].length <= decimals;
+}
+/**
+ * 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":"response-headers-policy.js","sourceRoot":"","sources":["../../../src/aws/edge/response-headers-policy.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/0f077c0a6adc1e5258d073f6de232d09cbb7ae54/packages/aws-cdk-lib/aws-cloudfront/lib/response-headers-policy.ts\nimport {\n  cloudfrontResponseHeadersPolicy,\n  dataAwsCloudfrontResponseHeadersPolicy,\n} from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Duration } from \"../../duration\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\n\n/**\n * Represents a response headers policy.\n */\nexport interface IResponseHeadersPolicy {\n  /**\n   * The ID of the response headers policy\n   * @attribute\n   **/\n  readonly responseHeadersPolicyId: string;\n}\n\n/**\n * Properties for creating a Response Headers Policy\n */\nexport interface ResponseHeadersPolicyProps extends AwsConstructProps {\n  /**\n   * A unique name to identify the response headers policy.\n   *\n   * @default - generated from the `id`\n   */\n  readonly responseHeadersPolicyName?: string;\n\n  /**\n   * A comment to describe the response headers policy.\n   *\n   * @default - no comment\n   */\n  readonly comment?: string;\n\n  /**\n   * A configuration for a set of HTTP response headers that are used for cross-origin resource sharing (CORS).\n   *\n   * @default - no cors behavior\n   */\n  readonly corsBehavior?: ResponseHeadersCorsBehavior;\n\n  /**\n   * A configuration for a set of custom HTTP response headers.\n   *\n   * @default - no custom headers behavior\n   */\n  readonly customHeadersBehavior?: ResponseCustomHeadersBehavior;\n\n  /**\n   * A configuration for a set of security-related HTTP response headers.\n   *\n   * @default - no security headers behavior\n   */\n  readonly securityHeadersBehavior?: ResponseSecurityHeadersBehavior;\n\n  /**\n   * A list of HTTP response headers that CloudFront removes from HTTP responses\n   * that it sends to viewers.\n   *\n   * @default - no headers are removed\n   */\n  readonly removeHeaders?: string[];\n\n  /**\n   * The percentage of responses that you want CloudFront to add the Server-Timing\n   * header to.\n   *\n   * @default - no Server-Timing header is added to HTTP responses\n   */\n  readonly serverTimingSamplingRate?: number;\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/resources/cloudfront_response_headers_policy\n */\nexport class ResponseHeadersPolicy\n  extends AwsConstructBase\n  implements IResponseHeadersPolicy\n{\n  /**\n   * Import an existing Response Headers Policy from its ID.\n   */\n  public static fromResponseHeadersPolicyId(\n    scope: Construct,\n    id: string,\n    responseHeadersPolicyId: string,\n  ): IResponseHeadersPolicy {\n    class Import extends AwsConstructBase implements IResponseHeadersPolicy {\n      public readonly outputs: Record<string, any> = {};\n      public readonly responseHeadersPolicyId = responseHeadersPolicyId;\n    }\n    return new Import(scope, id);\n  }\n\n  public static fromManagedPolicyName(\n    scope: Construct,\n    id: string,\n    managedResponseHeadersPolicyName: ManagedResponseHeadersPolicy,\n  ): IResponseHeadersPolicy {\n    class Import extends AwsConstructBase implements IResponseHeadersPolicy {\n      public readonly outputs: Record<string, any> = {};\n      public readonly responseHeadersPolicyId: string;\n      public readonly resource: dataAwsCloudfrontResponseHeadersPolicy.DataAwsCloudfrontResponseHeadersPolicy;\n      public constructor() {\n        super(scope, id);\n        this.resource =\n          new dataAwsCloudfrontResponseHeadersPolicy.DataAwsCloudfrontResponseHeadersPolicy(\n            this,\n            \"Resource\",\n            {\n              name: managedResponseHeadersPolicyName,\n            },\n          );\n        this.responseHeadersPolicyId = this.resource.id;\n      }\n    }\n    return new Import();\n  }\n\n  public readonly resource: cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicy;\n  public readonly responseHeadersPolicyId: string;\n  public readonly outputs: Record<string, any> = {};\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: ResponseHeadersPolicyProps = {},\n  ) {\n    super(scope, id, props);\n    const responseHeadersPolicyName =\n      props.responseHeadersPolicyName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        maxLength: 128,\n      });\n\n    this.resource =\n      new cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicy(\n        this,\n        \"Resource\",\n        {\n          name: responseHeadersPolicyName,\n          comment: props.comment,\n          corsConfig: props.corsBehavior\n            ? this._renderCorsConfig(props.corsBehavior)\n            : undefined,\n          customHeadersConfig: props.customHeadersBehavior\n            ? this._renderCustomHeadersConfig(props.customHeadersBehavior)\n            : undefined,\n          securityHeadersConfig: props.securityHeadersBehavior\n            ? this._renderSecurityHeadersConfig(props.securityHeadersBehavior)\n            : undefined,\n          removeHeadersConfig: props.removeHeaders\n            ? this._renderRemoveHeadersConfig(props.removeHeaders)\n            : undefined,\n          serverTimingHeadersConfig: props.serverTimingSamplingRate\n            ? this._renderServerTimingHeadersConfig(\n                props.serverTimingSamplingRate,\n              )\n            : undefined,\n        },\n      );\n\n    this.responseHeadersPolicyId = this.resource.id;\n  }\n\n  private _renderCorsConfig(\n    behavior: ResponseHeadersCorsBehavior,\n  ): cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicyCorsConfig {\n    return {\n      accessControlAllowCredentials: behavior.accessControlAllowCredentials,\n      accessControlAllowHeaders: { items: behavior.accessControlAllowHeaders },\n      accessControlAllowMethods: { items: behavior.accessControlAllowMethods },\n      accessControlAllowOrigins: { items: behavior.accessControlAllowOrigins },\n      accessControlExposeHeaders: behavior.accessControlExposeHeaders\n        ? { items: behavior.accessControlExposeHeaders }\n        : undefined,\n      accessControlMaxAgeSec: behavior.accessControlMaxAge\n        ? behavior.accessControlMaxAge.toSeconds()\n        : undefined,\n      originOverride: behavior.originOverride,\n    };\n  }\n\n  private _renderCustomHeadersConfig(\n    behavior: ResponseCustomHeadersBehavior,\n  ): cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicyCustomHeadersConfig {\n    return {\n      items: behavior.customHeaders,\n    };\n  }\n\n  private _renderSecurityHeadersConfig(\n    behavior: ResponseSecurityHeadersBehavior,\n  ): cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicySecurityHeadersConfig {\n    return {\n      contentSecurityPolicy: behavior.contentSecurityPolicy,\n      contentTypeOptions: behavior.contentTypeOptions,\n      frameOptions: behavior.frameOptions,\n      referrerPolicy: behavior.referrerPolicy,\n      strictTransportSecurity: behavior.strictTransportSecurity\n        ? {\n            ...behavior.strictTransportSecurity,\n            accessControlMaxAgeSec:\n              behavior.strictTransportSecurity.accessControlMaxAge.toSeconds(),\n          }\n        : undefined,\n      xssProtection: behavior.xssProtection,\n    };\n  }\n\n  private _renderRemoveHeadersConfig(\n    headers: string[],\n  ): cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicyRemoveHeadersConfig {\n    const readonlyHeaders = [\n      \"content-encoding\",\n      \"content-length\",\n      \"transfer-encoding\",\n      \"warning\",\n      \"via\",\n    ];\n\n    return {\n      items: headers.map((header) => {\n        if (\n          !Token.isUnresolved(header) &&\n          readonlyHeaders.includes(header.toLowerCase())\n        ) {\n          throw new Error(`Cannot remove read-only header ${header}`);\n        }\n        return { header };\n      }),\n    };\n  }\n\n  private _renderServerTimingHeadersConfig(\n    samplingRate: number,\n  ): cloudfrontResponseHeadersPolicy.CloudfrontResponseHeadersPolicyServerTimingHeadersConfig {\n    if (!Token.isUnresolved(samplingRate)) {\n      if (samplingRate < 0 || samplingRate > 100) {\n        throw new Error(\n          `Sampling rate must be between 0 and 100 (inclusive), received ${samplingRate}`,\n        );\n      }\n\n      if (!hasMaxDecimalPlaces(samplingRate, 4)) {\n        throw new Error(\n          `Sampling rate can have up to four decimal places, received ${samplingRate}`,\n        );\n      }\n    }\n\n    return {\n      enabled: true,\n      samplingRate,\n    };\n  }\n}\n\n/**\n * Configuration for a set of HTTP response headers that are used for cross-origin resource sharing (CORS).\n * CloudFront adds these headers to HTTP responses that it sends for CORS requests that match a cache behavior\n * associated with this response headers policy.\n */\nexport interface ResponseHeadersCorsBehavior {\n  /**\n   * A Boolean that CloudFront uses as the value for the Access-Control-Allow-Credentials HTTP response header.\n   */\n  readonly accessControlAllowCredentials: boolean;\n\n  /**\n   * A list of HTTP header names that CloudFront includes as values for the Access-Control-Allow-Headers HTTP response header.\n   * You can specify `['*']` to allow all headers.\n   */\n  readonly accessControlAllowHeaders: string[];\n\n  /**\n   * A list of HTTP methods that CloudFront includes as values for the Access-Control-Allow-Methods HTTP response header.\n   */\n  readonly accessControlAllowMethods: string[];\n\n  /**\n   * A list of origins (domain names) that CloudFront can use as the value for the Access-Control-Allow-Origin HTTP response header.\n   * You can specify `['*']` to allow all origins.\n   */\n  readonly accessControlAllowOrigins: string[];\n\n  /**\n   * A list of HTTP headers that CloudFront includes as values for the Access-Control-Expose-Headers HTTP response header.\n   * You can specify `['*']` to expose all headers.\n   *\n   * @default - no headers exposed\n   */\n  readonly accessControlExposeHeaders?: string[];\n\n  /**\n   * A number that CloudFront uses as the value for the Access-Control-Max-Age HTTP response header.\n   *\n   * @default - no max age\n   */\n  readonly accessControlMaxAge?: Duration;\n\n  /**\n   * A Boolean that determines whether CloudFront overrides HTTP response headers received from the origin with the ones specified in this response headers policy.\n   */\n  readonly originOverride: boolean;\n}\n\n/**\n * Configuration for a set of HTTP response headers that are sent for requests that match a cache behavior\n * that’s associated with this response headers policy.\n */\nexport interface ResponseCustomHeadersBehavior {\n  /**\n   * The list of HTTP response headers and their values.\n   */\n  readonly customHeaders: ResponseCustomHeader[];\n}\n\n/**\n * An HTTP response header name and its value.\n * CloudFront includes this header in HTTP responses that it sends for requests that match a cache behavior that’s associated with this response headers policy.\n */\nexport interface ResponseCustomHeader {\n  /**\n   * The HTTP response header name.\n   */\n  readonly header: string;\n\n  /**\n   * A Boolean that determines whether CloudFront overrides a response header with the same name\n   * received from the origin with the header specified here.\n   */\n  readonly override: boolean;\n\n  /**\n   * The value for the HTTP response header.\n   */\n  readonly value: string;\n}\n\n/**\n * Configuration for a set of security-related HTTP response headers.\n * CloudFront adds these headers to HTTP responses that it sends for requests that match a cache behavior\n * associated with this response headers policy.\n */\nexport interface ResponseSecurityHeadersBehavior {\n  /**\n   * The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.\n   *\n   * @default - no content security policy\n   */\n  readonly contentSecurityPolicy?: ResponseHeadersContentSecurityPolicy;\n\n  /**\n   * Determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff.\n   *\n   * @default - no content type options\n   */\n  readonly contentTypeOptions?: ResponseHeadersContentTypeOptions;\n\n  /**\n   * Determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value.\n   *\n   * @default - no frame options\n   */\n  readonly frameOptions?: ResponseHeadersFrameOptions;\n\n  /**\n   * Determines whether CloudFront includes the Referrer-Policy HTTP response header and the header’s value.\n   *\n   * @default - no referrer policy\n   */\n  readonly referrerPolicy?: ResponseHeadersReferrerPolicy;\n\n  /**\n   * Determines whether CloudFront includes the Strict-Transport-Security HTTP response header and the header’s value.\n   *\n   * @default - no strict transport security\n   */\n  readonly strictTransportSecurity?: ResponseHeadersStrictTransportSecurity;\n\n  /**\n   * Determines whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value.\n   *\n   * @default - no xss protection\n   */\n  readonly xssProtection?: ResponseHeadersXSSProtection;\n}\n\n/**\n * The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.\n */\nexport interface ResponseHeadersContentSecurityPolicy {\n  /**\n   * The policy directives and their values that CloudFront includes as values for the Content-Security-Policy HTTP response header.\n   */\n  readonly contentSecurityPolicy: string;\n\n  /**\n   * A Boolean that determines whether CloudFront overrides the Content-Security-Policy HTTP response header\n   * received from the origin with the one specified in this response headers policy.\n   */\n  readonly override: boolean;\n}\n\n/**\n * Determines whether CloudFront includes the X-Content-Type-Options HTTP response header with its value set to nosniff.\n */\nexport interface ResponseHeadersContentTypeOptions {\n  /**\n   * A Boolean that determines whether CloudFront overrides the X-Content-Type-Options HTTP response header\n   * received from the origin with the one specified in this response headers policy.\n   */\n  readonly override: boolean;\n}\n\n/**\n * Determines whether CloudFront includes the X-Frame-Options HTTP response header and the header’s value.\n */\nexport interface ResponseHeadersFrameOptions {\n  /**\n   * The value of the X-Frame-Options HTTP response header.\n   */\n  readonly frameOption: HeadersFrameOption;\n\n  /**\n   * A Boolean that determines whether CloudFront overrides the X-Frame-Options HTTP response header\n   * received from the origin with the one specified in this response headers policy.\n   */\n  readonly override: boolean;\n}\n\n/**\n * Determines whether CloudFront includes the Referrer-Policy HTTP response header and the header’s value.\n */\nexport interface ResponseHeadersReferrerPolicy {\n  /**\n   * The value of the Referrer-Policy HTTP response header.\n   */\n  readonly referrerPolicy: HeadersReferrerPolicy;\n\n  /**\n   * A Boolean that determines whether CloudFront overrides the Referrer-Policy HTTP response header\n   * received from the origin with the one specified in this response headers policy.\n   */\n  readonly override: boolean;\n}\n\n/**\n * Determines whether CloudFront includes the Strict-Transport-Security HTTP response header and the header’s value.\n */\nexport interface ResponseHeadersStrictTransportSecurity {\n  /**\n   * A number that CloudFront uses as the value for the max-age directive in the Strict-Transport-Security HTTP response header.\n   */\n  readonly accessControlMaxAge: Duration;\n\n  /**\n   * A Boolean that determines whether CloudFront includes the includeSubDomains directive in the Strict-Transport-Security HTTP response header.\n   *\n   * @default false\n   */\n  readonly includeSubdomains?: boolean;\n\n  /**\n   * A Boolean that determines whether CloudFront overrides the Strict-Transport-Security HTTP response header\n   * received from the origin with the one specified in this response headers policy.\n   */\n  readonly override: boolean;\n\n  /**\n   * A Boolean that determines whether CloudFront includes the preload directive in the Strict-Transport-Security HTTP response header.\n   *\n   * @default false\n   */\n  readonly preload?: boolean;\n}\n\n/**\n * Determines whether CloudFront includes the X-XSS-Protection HTTP response header and the header’s value.\n */\nexport interface ResponseHeadersXSSProtection {\n  /**\n   * A Boolean that determines whether CloudFront includes the mode=block directive in the X-XSS-Protection header.\n   *\n   * @default false\n   */\n  readonly modeBlock?: boolean;\n\n  /**\n   * A Boolean that determines whether CloudFront overrides the X-XSS-Protection HTTP response header\n   * received from the origin with the one specified in this response headers policy.\n   */\n  readonly override: boolean;\n\n  /**\n   * A Boolean that determines the value of the X-XSS-Protection HTTP response header.\n   * When this setting is true, the value of the X-XSS-Protection header is 1.\n   * When this setting is false, the value of the X-XSS-Protection header is 0.\n   */\n  readonly protection: boolean;\n\n  /**\n   * A reporting URI, which CloudFront uses as the value of the report directive in the X-XSS-Protection header.\n   * You cannot specify a ReportUri when ModeBlock is true.\n   *\n   * @default - no report uri\n   */\n  readonly reportUri?: string;\n}\n\n/**\n * Enum representing possible values of the X-Frame-Options HTTP response header.\n */\nexport enum HeadersFrameOption {\n  /**\n   * The page can only be displayed in a frame on the same origin as the page itself.\n   */\n  DENY = \"DENY\",\n\n  /**\n   * The page can only be displayed in a frame on the specified origin.\n   */\n  SAMEORIGIN = \"SAMEORIGIN\",\n}\n\n/**\n * Enum representing possible values of the Referrer-Policy HTTP response header.\n */\nexport enum HeadersReferrerPolicy {\n  /**\n   * The referrer policy is not set.\n   */\n  NO_REFERRER = \"no-referrer\",\n\n  /**\n   * The referrer policy is no-referrer-when-downgrade.\n   */\n  NO_REFERRER_WHEN_DOWNGRADE = \"no-referrer-when-downgrade\",\n\n  /**\n   * The referrer policy is origin.\n   */\n  ORIGIN = \"origin\",\n\n  /**\n   * The referrer policy is origin-when-cross-origin.\n   */\n  ORIGIN_WHEN_CROSS_ORIGIN = \"origin-when-cross-origin\",\n\n  /**\n   * The referrer policy is same-origin.\n   */\n  SAME_ORIGIN = \"same-origin\",\n\n  /**\n   * The referrer policy is strict-origin.\n   */\n  STRICT_ORIGIN = \"strict-origin\",\n\n  /**\n   * The referrer policy is strict-origin-when-cross-origin.\n   */\n  STRICT_ORIGIN_WHEN_CROSS_ORIGIN = \"strict-origin-when-cross-origin\",\n\n  /**\n   * The referrer policy is unsafe-url.\n   */\n  UNSAFE_URL = \"unsafe-url\",\n}\n\nfunction hasMaxDecimalPlaces(num: number, decimals: number): boolean {\n  const parts = num.toString().split(\".\");\n  return parts.length === 1 || parts[1].length <= decimals;\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"]}