terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/alb/application-listener.js

@@ -0,0 +1,538 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationListener = exports.MutualAuthenticationMode = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/application-listener.ts
+const cdktf_1 = require("cdktf");
+const application_listener_action_1 = require("./application-listener-action");
+const application_listener_certificate_1 = require("./application-listener-certificate");
+const application_listener_rule_1 = require("./application-listener-rule");
+const application_target_group_1 = require("./application-target-group");
+const aws_construct_1 = require("../../aws-construct");
+const connections_1 = require("../connections");
+const base_listener_1 = require("../lb-shared/base-listener");
+const enums_1 = require("../lb-shared/enums");
+// import {
+//   LoadBalancerType,
+//   LoadBalancerListenerProtocol,
+// } from "../lb-shared/grid-lookup-types";
+const listener_certificate_1 = require("../lb-shared/listener-certificate");
+const util_1 = require("../lb-shared/util");
+const peer_1 = require("../peer");
+const port_1 = require("../port");
+/**
+ * The client certificate handling method
+ */
+var MutualAuthenticationMode;
+(function (MutualAuthenticationMode) {
+    /**
+     * Off
+     */
+    MutualAuthenticationMode["OFF"] = "off";
+    /**
+     * Application Load Balancer sends the whole client certificate chain to the target using HTTP headers
+     */
+    MutualAuthenticationMode["PASS_THROUGH"] = "passthrough";
+    /**
+     * Application Load Balancer performs X.509 client certificate authentication for clients when a load balancer negotiates TLS connections
+     */
+    MutualAuthenticationMode["VERIFY"] = "verify";
+})(MutualAuthenticationMode || (exports.MutualAuthenticationMode = MutualAuthenticationMode = {}));
+/**
+ * Define an ApplicationListener
+ *
+ * @resource AWS::ElasticLoadBalancingV2::Listener
+ */
+class ApplicationListener extends base_listener_1.BaseListener {
+    // TODO: Add Grid Lookup support
+    // /**
+    //  * Look up an ApplicationListener.
+    //  */
+    // public static fromLookup(
+    //   scope: Construct,
+    //   id: string,
+    //   options: ApplicationListenerLookupOptions,
+    // ): IApplicationListener {
+    //   if (Token.isUnresolved(options.listenerArn)) {
+    //     throw new Error(
+    //       "All arguments to look up a load balancer listener must be concrete (no Tokens)",
+    //     );
+    //   }
+    //   let listenerProtocol: LoadBalancerListenerProtocol | undefined;
+    //   switch (options.listenerProtocol) {
+    //     case ApplicationProtocol.HTTP:
+    //       listenerProtocol = LoadBalancerListenerProtocol.HTTP;
+    //       break;
+    //     case ApplicationProtocol.HTTPS:
+    //       listenerProtocol = LoadBalancerListenerProtocol.HTTPS;
+    //       break;
+    //   }
+    //   const props = BaseListener._queryContextProvider(scope, {
+    //     userOptions: options,
+    //     loadBalancerType: LoadBalancerType.APPLICATION,
+    //     listenerArn: options.listenerArn,
+    //     listenerProtocol,
+    //   });
+    //   return new LookedUpApplicationListener(scope, id, props);
+    // }
+    /**
+     * Import an existing listener
+     */
+    static fromApplicationListenerAttributes(scope, id, attrs) {
+        return new ImportedApplicationListener(scope, id, attrs);
+    }
+    constructor(scope, id, props) {
+        const [protocol, port] = (0, util_1.determineProtocolAndPort)(props.protocol, props.port);
+        if (protocol === undefined || port === undefined) {
+            throw new Error("At least one of 'port' or 'protocol' is required");
+        }
+        validateMutualAuthentication(props.mutualAuthentication);
+        super(scope, id, {
+            loadBalancerArn: props.loadBalancer.loadBalancerArn,
+            certificateArn: cdktf_1.Lazy.stringValue({
+                produce: () => this.certificateArns.length > 0 ? this.certificateArns[0] : undefined,
+            }),
+            protocol,
+            port,
+            sslPolicy: props.sslPolicy,
+            // https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/lb_listener#mutual_authentication
+            mutualAuthentication: props.mutualAuthentication &&
+                Object.keys(props.mutualAuthentication).length > 0
+                ? {
+                    ignoreClientCertificateExpiry: props.mutualAuthentication?.ignoreClientCertificateExpiry,
+                    // CFN Default is off
+                    // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-mutualauthentication.html#cfn-elasticloadbalancingv2-listener-mutualauthentication-mode
+                    mode: props.mutualAuthentication?.mutualAuthenticationMode ??
+                        MutualAuthenticationMode.OFF,
+                    trustStoreArn: props.mutualAuthentication?.trustStore?.trustStoreArn,
+                }
+                : undefined,
+        });
+        this.loadBalancer = props.loadBalancer;
+        this.protocol = protocol;
+        this.port = port;
+        this.certificateArns = [];
+        // Attach certificates
+        if (props.certificateArns && props.certificateArns.length > 0) {
+            this.addCertificateArns("ListenerCertificate", props.certificateArns);
+        }
+        if (props.certificates && props.certificates.length > 0) {
+            this.addCertificates("DefaultCertificates", props.certificates);
+        }
+        // This listener edits the securitygroup of the load balancer,
+        // but adds its own default port.
+        this.connections = new connections_1.Connections({
+            securityGroups: props.loadBalancer.connections.securityGroups,
+            defaultPort: port_1.Port.tcp(port),
+        });
+        if (props.defaultAction && props.defaultTargetGroups) {
+            throw new Error("Specify at most one of 'defaultAction' and 'defaultTargetGroups'");
+        }
+        if (props.defaultAction) {
+            this.setDefaultAction(props.defaultAction);
+        }
+        if (props.defaultTargetGroups) {
+            this.setDefaultAction(application_listener_action_1.ListenerAction.forward(props.defaultTargetGroups));
+        }
+        if (props.open !== false) {
+            this.connections.allowDefaultPortFrom(peer_1.Peer.anyIpv4(), `Allow from anyone on port ${port}`);
+            // When enabled, the default security group ingress rules will allow IPv6 ingress from anywhere
+            // recommendedValue: true
+            // FeatureFlags.of(this).isEnabled(
+            //   cxapi.ALB_DUALSTACK_WITHOUT_PUBLIC_IPV4_SECURITY_GROUP_RULES_DEFAULT,
+            // )
+            if (this.loadBalancer.ipAddressType === enums_1.IpAddressType.DUAL_STACK ||
+                this.loadBalancer.ipAddressType ===
+                    enums_1.IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4) {
+                this.connections.allowDefaultPortFrom(peer_1.Peer.anyIpv6(), `Allow from anyone on port ${port}`);
+            }
+        }
+    }
+    /**
+     * Add one or more certificates to this listener.
+     *
+     * After the first certificate, this creates ApplicationListenerCertificates
+     * resources since cloudformation requires the certificates array on the
+     * listener resource to have a length of 1.
+     *
+     * @deprecated Use `addCertificates` instead.
+     */
+    addCertificateArns(id, arns) {
+        this.addCertificates(id, arns.map(listener_certificate_1.ListenerCertificate.fromArn));
+    }
+    /**
+     * Add one or more certificates to this listener.
+     *
+     * After the first certificate, this creates ApplicationListenerCertificates
+     * resources since cloudformation requires the certificates array on the
+     * listener resource to have a length of 1.
+     */
+    addCertificates(id, certificates) {
+        const additionalCerts = [...certificates];
+        if (this.certificateArns.length === 0 && additionalCerts.length > 0) {
+            const first = additionalCerts.splice(0, 1)[0];
+            this.certificateArns.push(first.certificateArn);
+        }
+        // Only one certificate can be specified per resource, even though
+        // `certificates` is of type Array
+        for (let i = 0; i < additionalCerts.length; i++) {
+            new application_listener_certificate_1.ApplicationListenerCertificate(this, `${id}${i + 1}`, {
+                listener: this,
+                certificates: [additionalCerts[i]],
+            });
+        }
+    }
+    /**
+     * Perform the given default action on incoming requests
+     *
+     * This allows full control of the default action of the load balancer,
+     * including Action chaining, fixed responses and redirect responses. See
+     * the `ListenerAction` class for all options.
+     *
+     * It's possible to add routing conditions to the Action added in this way.
+     * At least one Action must be added without conditions (which becomes the
+     * default Action).
+     */
+    addAction(id, props) {
+        checkAddRuleProps(props);
+        if (props.priority !== undefined) {
+            // New rule
+            //
+            // TargetGroup.registerListener is called inside ApplicationListenerRule.
+            new application_listener_rule_1.ApplicationListenerRule(this, id + "Rule", {
+                listener: this,
+                priority: props.priority,
+                ...props,
+            });
+        }
+        else {
+            // New default target with these targetgroups
+            this.setDefaultAction(props.action);
+        }
+    }
+    /**
+     * Load balance incoming requests to the given target groups.
+     *
+     * All target groups will be load balanced to with equal weight and without
+     * stickiness. For a more complex configuration than that, use `addAction()`.
+     *
+     * It's possible to add routing conditions to the TargetGroups added in this
+     * way. At least one TargetGroup must be added without conditions (which will
+     * become the default Action for this listener).
+     */
+    addTargetGroups(id, props) {
+        checkAddRuleProps(props);
+        if (props.priority !== undefined) {
+            // New rule
+            //
+            // TargetGroup.registerListener is called inside ApplicationListenerRule.
+            new application_listener_rule_1.ApplicationListenerRule(this, id + "Rule", {
+                listener: this,
+                priority: props.priority,
+                ...props,
+            });
+        }
+        else {
+            // New default target with these targetgroups
+            this.setDefaultAction(application_listener_action_1.ListenerAction.forward(props.targetGroups));
+        }
+    }
+    /**
+     * Load balance incoming requests to the given load balancing targets.
+     *
+     * This method implicitly creates an ApplicationTargetGroup for the targets
+     * involved, and a 'forward' action to route traffic to the given TargetGroup.
+     *
+     * If you want more control over the precise setup, create the TargetGroup
+     * and use `addAction` yourself.
+     *
+     * It's possible to add conditions to the targets added in this way. At least
+     * one set of targets must be added without conditions.
+     *
+     * @returns The newly created target group
+     */
+    addTargets(id, props) {
+        if (!this.loadBalancer.vpc) {
+            // eslint-disable-next-line max-len
+            throw new Error("Can only call addTargets() when using a constructed Load Balancer or an imported Load Balancer with specified vpc; construct a new TargetGroup and use addTargetGroup");
+        }
+        const group = new application_target_group_1.ApplicationTargetGroup(this, id + "Group", {
+            vpc: this.loadBalancer.vpc,
+            ...props,
+        });
+        this.addTargetGroups(id, {
+            targetGroups: [group],
+            ...props,
+        });
+        return group;
+    }
+    /**
+     * Add a fixed response
+     *
+     * @deprecated Use `addAction()` instead
+     */
+    addFixedResponse(id, props) {
+        checkAddRuleProps(props);
+        const fixedResponse = {
+            statusCode: props.statusCode,
+            contentType: props.contentType ?? application_listener_rule_1.ContentType.TEXT_PLAIN,
+            messageBody: props.messageBody,
+        };
+        /**
+         * NOTE - Copy/pasted from `application-listener-rule.ts#validateFixedResponse`.
+         * This was previously a deprecated, exported function, which caused issues with jsii's strip-deprecated functionality.
+         * Inlining the duplication functionality in v2 only (for now).
+         */
+        if (fixedResponse.statusCode &&
+            !/^(2|4|5)\d\d$/.test(fixedResponse.statusCode)) {
+            throw new Error("`statusCode` must be 2XX, 4XX or 5XX.");
+        }
+        if (fixedResponse.messageBody && fixedResponse.messageBody.length > 1024) {
+            throw new Error("`messageBody` cannot have more than 1024 characters.");
+        }
+        if (props.priority) {
+            new application_listener_rule_1.ApplicationListenerRule(this, id + "Rule", {
+                listener: this,
+                priority: props.priority,
+                fixedResponse,
+                ...props,
+            });
+        }
+        else {
+            this.setDefaultAction(application_listener_action_1.ListenerAction.fixedResponse(cdktf_1.Token.asNumber(props.statusCode), {
+                contentType: props.contentType ?? application_listener_rule_1.ContentType.TEXT_PLAIN,
+                messageBody: props.messageBody,
+            }));
+        }
+    }
+    /**
+     * Add a redirect response
+     *
+     * @deprecated Use `addAction()` instead
+     */
+    addRedirectResponse(id, props) {
+        checkAddRuleProps(props);
+        const redirectResponse = {
+            host: props.host,
+            path: props.path,
+            port: props.port,
+            protocol: props.protocol,
+            query: props.query,
+            statusCode: props.statusCode,
+        };
+        /**
+         * NOTE - Copy/pasted from `application-listener-rule.ts#validateRedirectResponse`.
+         * This was previously a deprecated, exported function, which caused issues with jsii's strip-deprecated functionality.
+         * Inlining the duplication functionality in v2 only (for now).
+         */
+        if (redirectResponse.protocol &&
+            !/^(HTTPS?|#\{protocol\})$/i.test(redirectResponse.protocol)) {
+            throw new Error("`protocol` must be HTTP, HTTPS, or #{protocol}.");
+        }
+        if (!redirectResponse.statusCode ||
+            !/^HTTP_30[12]$/.test(redirectResponse.statusCode)) {
+            throw new Error("`statusCode` must be HTTP_301 or HTTP_302.");
+        }
+        if (props.priority) {
+            new application_listener_rule_1.ApplicationListenerRule(this, id + "Rule", {
+                listener: this,
+                priority: props.priority,
+                redirectResponse,
+                ...props,
+            });
+        }
+        else {
+            this.setDefaultAction(application_listener_action_1.ListenerAction.redirect({
+                host: props.host,
+                path: props.path,
+                port: props.port,
+                protocol: props.protocol,
+                query: props.query,
+                permanent: props.statusCode === "HTTP_301",
+            }));
+        }
+    }
+    /**
+     * Register that a connectable that has been added to this load balancer.
+     *
+     * Don't call this directly. It is called by ApplicationTargetGroup.
+     */
+    registerConnectable(connectable, portRange) {
+        connectable.connections.allowFrom(this.loadBalancer, portRange, "Load balancer to target");
+    }
+    /**
+     * Validate this listener.
+     */
+    validateListener() {
+        const errors = super.validateListener();
+        if (this.protocol === enums_1.ApplicationProtocol.HTTPS &&
+            this.certificateArns.length === 0) {
+            errors.push("HTTPS Listener needs at least one certificate (call addCertificates)");
+        }
+        return errors;
+    }
+    /**
+     * Wrapper for _setDefaultAction which does a type-safe bind
+     */
+    setDefaultAction(action) {
+        action.bind(this, this);
+        this._setDefaultAction(action);
+    }
+}
+exports.ApplicationListener = ApplicationListener;
+_a = JSII_RTTI_SYMBOL_1;
+ApplicationListener[_a] = { fqn: "terraconstructs.aws.compute.ApplicationListener", version: "0.0.12" };
+class ExternalApplicationListener extends aws_construct_1.AwsConstructBase {
+    get listenerOutputs() {
+        return {
+            listenerArn: this.listenerArn,
+        };
+    }
+    get outputs() {
+        return this.listenerOutputs;
+    }
+    constructor(scope, id) {
+        super(scope, id);
+    }
+    /**
+     * Register that a connectable that has been added to this load balancer.
+     *
+     * Don't call this directly. It is called by ApplicationTargetGroup.
+     */
+    registerConnectable(connectable, portRange) {
+        this.connections.allowTo(connectable, portRange, "Load balancer to target");
+    }
+    /**
+     * Add one or more certificates to this listener.
+     * @deprecated use `addCertificates()`
+     */
+    addCertificateArns(id, arns) {
+        this.addCertificates(id, arns.map(listener_certificate_1.ListenerCertificate.fromArn));
+    }
+    /**
+     * Add one or more certificates to this listener.
+     */
+    addCertificates(id, certificates) {
+        new application_listener_certificate_1.ApplicationListenerCertificate(this, id, {
+            listener: this,
+            certificates,
+        });
+    }
+    /**
+     * Load balance incoming requests to the given target groups.
+     *
+     * It's possible to add conditions to the TargetGroups added in this way.
+     * At least one TargetGroup must be added without conditions.
+     */
+    addTargetGroups(id, props) {
+        checkAddRuleProps(props);
+        if (props.priority !== undefined) {
+            // New rule
+            new application_listener_rule_1.ApplicationListenerRule(this, id, {
+                listener: this,
+                priority: props.priority,
+                ...props,
+            });
+        }
+        else {
+            throw new Error("Cannot add default Target Groups to imported ApplicationListener");
+        }
+    }
+    /**
+     * Load balance incoming requests to the given load balancing targets.
+     *
+     * This method implicitly creates an ApplicationTargetGroup for the targets
+     * involved.
+     *
+     * It's possible to add conditions to the targets added in this way. At least
+     * one set of targets must be added without conditions.
+     *
+     * @returns The newly created target group
+     */
+    addTargets(_id, _props) {
+        // eslint-disable-next-line max-len
+        throw new Error("Can only call addTargets() when using a constructed ApplicationListener; construct a new TargetGroup and use addTargetGroup.");
+    }
+    /**
+     * Perform the given action on incoming requests
+     *
+     * This allows full control of the default action of the load balancer,
+     * including Action chaining, fixed responses and redirect responses. See
+     * the `ListenerAction` class for all options.
+     *
+     * It's possible to add routing conditions to the Action added in this way.
+     *
+     * It is not possible to add a default action to an imported IApplicationListener.
+     * In order to add actions to an imported IApplicationListener a `priority`
+     * must be provided.
+     *
+     * If you previously deployed a `ListenerRule` using the `addTargetGroups()` method
+     * and need to migrate to using the more feature rich `addAction()`
+     * method, then you will need to set the `removeRuleSuffixFromLogicalId: true`
+     * property here to avoid having CloudFormation attempt to replace your resource.
+     */
+    addAction(id, props) {
+        checkAddRuleProps(props);
+        if (props.priority !== undefined) {
+            const ruleId = props.removeSuffix ? id : id + "Rule";
+            // New rule
+            //
+            // TargetGroup.registerListener is called inside ApplicationListenerRule.
+            new application_listener_rule_1.ApplicationListenerRule(this, ruleId, {
+                listener: this,
+                priority: props.priority,
+                ...props,
+            });
+        }
+        else {
+            throw new Error("priority must be set for actions added to an imported listener");
+        }
+    }
+}
+/**
+ * An imported application listener.
+ */
+class ImportedApplicationListener extends ExternalApplicationListener {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.listenerArn = props.listenerArn;
+        const defaultPort = props.defaultPort !== undefined ? port_1.Port.tcp(props.defaultPort) : undefined;
+        this.connections = new connections_1.Connections({
+            securityGroups: [props.securityGroup],
+            defaultPort,
+        });
+    }
+}
+function checkAddRuleProps(props) {
+    const conditionsCount = props.conditions?.length || 0;
+    const hasAnyConditions = conditionsCount !== 0 ||
+        props.hostHeader !== undefined ||
+        props.pathPattern !== undefined ||
+        props.pathPatterns !== undefined;
+    const hasPriority = props.priority !== undefined;
+    if (hasAnyConditions !== hasPriority) {
+        throw new Error("Setting 'conditions', 'pathPattern' or 'hostHeader' also requires 'priority', and vice versa");
+    }
+}
+function validateMutualAuthentication(mutualAuthentication) {
+    if (!mutualAuthentication) {
+        return;
+    }
+    const currentMode = mutualAuthentication.mutualAuthenticationMode;
+    if (currentMode === MutualAuthenticationMode.VERIFY) {
+        if (!mutualAuthentication.trustStore) {
+            throw new Error(`You must set 'trustStore' when 'mode' is '${MutualAuthenticationMode.VERIFY}'`);
+        }
+    }
+    if (currentMode === MutualAuthenticationMode.OFF ||
+        currentMode === MutualAuthenticationMode.PASS_THROUGH) {
+        if (mutualAuthentication.trustStore) {
+            throw new Error(`You cannot set 'trustStore' when 'mode' is '${MutualAuthenticationMode.OFF}' or '${MutualAuthenticationMode.PASS_THROUGH}'`);
+        }
+        if (mutualAuthentication.ignoreClientCertificateExpiry !== undefined) {
+            throw new Error(`You cannot set 'ignoreClientCertificateExpiry' when 'mode' is '${MutualAuthenticationMode.OFF}' or '${MutualAuthenticationMode.PASS_THROUGH}'`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application-listener.js","sourceRoot":"","sources":["../../../../src/aws/compute/alb/application-listener.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/application-listener.ts\n\nimport { Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ListenerAction } from \"./application-listener-action\";\nimport { ApplicationListenerCertificate } from \"./application-listener-certificate\";\nimport {\n  ApplicationListenerRule,\n  ContentType,\n  FixedResponse,\n  RedirectResponse,\n} from \"./application-listener-rule\";\nimport { IApplicationLoadBalancer } from \"./application-load-balancer\";\nimport {\n  ApplicationTargetGroup,\n  IApplicationLoadBalancerTarget,\n  IApplicationTargetGroup,\n} from \"./application-target-group\";\nimport { ListenerCondition } from \"./conditions\";\nimport { ITrustStore } from \"./trust-store\";\nimport { Duration } from \"../../../duration\";\nimport { AwsConstructBase } from \"../../aws-construct\";\nimport { Connections, IConnectable } from \"../connections\";\nimport {\n  BaseListener,\n  BaseListenerLookupOptions,\n  IListener,\n  ListenerOutputs,\n} from \"../lb-shared/base-listener\";\nimport { HealthCheck } from \"../lb-shared/base-target-group\";\nimport {\n  ApplicationProtocol,\n  ApplicationProtocolVersion,\n  TargetGroupLoadBalancingAlgorithmType,\n  IpAddressType,\n  SslPolicy,\n} from \"../lb-shared/enums\";\n// import {\n//   LoadBalancerType,\n//   LoadBalancerListenerProtocol,\n// } from \"../lb-shared/grid-lookup-types\";\nimport {\n  IListenerCertificate,\n  ListenerCertificate,\n} from \"../lb-shared/listener-certificate\";\nimport { determineProtocolAndPort } from \"../lb-shared/util\";\nimport { Peer } from \"../peer\";\nimport { Port } from \"../port\";\nimport { ISecurityGroup } from \"../security-group\";\n\n/**\n * Basic properties for an ApplicationListener\n */\nexport interface BaseApplicationListenerProps {\n  /**\n   * The protocol to use\n   *\n   * @default - Determined from port if known.\n   */\n  readonly protocol?: ApplicationProtocol;\n\n  /**\n   * The port on which the listener listens for requests.\n   *\n   * @default - Determined from protocol if known.\n   */\n  readonly port?: number;\n\n  /**\n   * The certificates to use on this listener\n   *\n   * @default - No certificates.\n   * @deprecated Use the `certificates` property instead\n   */\n  readonly certificateArns?: string[];\n\n  /**\n   * Certificate list of ACM cert ARNs. You must provide exactly one certificate if the listener protocol is HTTPS or TLS.\n   *\n   * @default - No certificates.\n   */\n  readonly certificates?: IListenerCertificate[];\n\n  /**\n   * The security policy that defines which ciphers and protocols are supported.\n   *\n   * @default - The current predefined security policy.\n   */\n  readonly sslPolicy?: SslPolicy;\n\n  /**\n   * Default target groups to load balance to\n   *\n   * All target groups will be load balanced to with equal weight and without\n   * stickiness. For a more complex configuration than that, use\n   * either `defaultAction` or `addAction()`.\n   *\n   * Cannot be specified together with `defaultAction`.\n   *\n   * @default - None.\n   */\n  readonly defaultTargetGroups?: IApplicationTargetGroup[];\n\n  /**\n   * Default action to take for requests to this listener\n   *\n   * This allows full control of the default action of the load balancer,\n   * including Action chaining, fixed responses and redirect responses.\n   *\n   * See the `ListenerAction` class for all options.\n   *\n   * Cannot be specified together with `defaultTargetGroups`.\n   *\n   * @default - None.\n   */\n  readonly defaultAction?: ListenerAction;\n\n  /**\n   * Allow anyone to connect to the load balancer on the listener port\n   *\n   * If this is specified, the load balancer will be opened up to anyone who can reach it.\n   * For internal load balancers this is anyone in the same VPC. For public load\n   * balancers, this is anyone on the internet.\n   *\n   * If you want to be more selective about who can access this load\n   * balancer, set this to `false` and use the listener's `connections`\n   * object to selectively grant access to the load balancer on the listener port.\n   *\n   * @default true\n   */\n  readonly open?: boolean;\n\n  /**\n   * The mutual authentication configuration information\n   *\n   * @default - No mutual authentication configuration\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/mutual-authentication.html\n   * @see https://registry.terraform.io/providers/hashicorp/aws/5.87.0/docs/resources/lb_listener#mutual_authentication\n   */\n  readonly mutualAuthentication?: MutualAuthentication;\n}\n\n/**\n * The mutual authentication configuration information\n *\n */\nexport interface MutualAuthentication {\n  /**\n   * The client certificate handling method\n   *\n   * @default MutualAuthenticationMode.OFF\n   */\n  readonly mutualAuthenticationMode?: MutualAuthenticationMode;\n\n  /**\n   * The trust store\n   *\n   * Cannot be used with MutualAuthenticationMode.OFF or MutualAuthenticationMode.PASS_THROUGH\n   *\n   * @default - no trust store\n   */\n  readonly trustStore?: ITrustStore;\n\n  /**\n   * Indicates whether expired client certificates are ignored\n   *\n   * Cannot be used with MutualAuthenticationMode.OFF or MutualAuthenticationMode.PASS_THROUGH\n   *\n   * @default false\n   */\n  readonly ignoreClientCertificateExpiry?: boolean;\n}\n\n/**\n * The client certificate handling method\n */\nexport enum MutualAuthenticationMode {\n  /**\n   * Off\n   */\n  OFF = \"off\",\n\n  /**\n   * Application Load Balancer sends the whole client certificate chain to the target using HTTP headers\n   */\n  PASS_THROUGH = \"passthrough\",\n\n  /**\n   * Application Load Balancer performs X.509 client certificate authentication for clients when a load balancer negotiates TLS connections\n   */\n  VERIFY = \"verify\",\n}\n\n/**\n * Properties for defining a standalone ApplicationListener\n */\nexport interface ApplicationListenerProps extends BaseApplicationListenerProps {\n  /**\n   * The load balancer to attach this listener to\n   */\n  readonly loadBalancer: IApplicationLoadBalancer;\n}\n\n/**\n * Options for ApplicationListener lookup\n */\nexport interface ApplicationListenerLookupOptions\n  extends BaseListenerLookupOptions {\n  /**\n   * ARN of the listener to look up\n   * @default - does not filter by listener arn\n   */\n  readonly listenerArn?: string;\n\n  /**\n   * Filter listeners by listener protocol\n   * @default - does not filter by listener protocol\n   */\n  readonly listenerProtocol?: ApplicationProtocol;\n}\n\n/**\n * Define an ApplicationListener\n *\n * @resource AWS::ElasticLoadBalancingV2::Listener\n */\nexport class ApplicationListener\n  extends BaseListener\n  implements IApplicationListener\n{\n  // TODO: Add Grid Lookup support\n  // /**\n  //  * Look up an ApplicationListener.\n  //  */\n  // public static fromLookup(\n  //   scope: Construct,\n  //   id: string,\n  //   options: ApplicationListenerLookupOptions,\n  // ): IApplicationListener {\n  //   if (Token.isUnresolved(options.listenerArn)) {\n  //     throw new Error(\n  //       \"All arguments to look up a load balancer listener must be concrete (no Tokens)\",\n  //     );\n  //   }\n\n  //   let listenerProtocol: LoadBalancerListenerProtocol | undefined;\n  //   switch (options.listenerProtocol) {\n  //     case ApplicationProtocol.HTTP:\n  //       listenerProtocol = LoadBalancerListenerProtocol.HTTP;\n  //       break;\n  //     case ApplicationProtocol.HTTPS:\n  //       listenerProtocol = LoadBalancerListenerProtocol.HTTPS;\n  //       break;\n  //   }\n\n  //   const props = BaseListener._queryContextProvider(scope, {\n  //     userOptions: options,\n  //     loadBalancerType: LoadBalancerType.APPLICATION,\n  //     listenerArn: options.listenerArn,\n  //     listenerProtocol,\n  //   });\n\n  //   return new LookedUpApplicationListener(scope, id, props);\n  // }\n\n  /**\n   * Import an existing listener\n   */\n  public static fromApplicationListenerAttributes(\n    scope: Construct,\n    id: string,\n    attrs: ApplicationListenerAttributes,\n  ): IApplicationListener {\n    return new ImportedApplicationListener(scope, id, attrs);\n  }\n\n  /**\n   * Manage connections to this ApplicationListener\n   */\n  public readonly connections: Connections;\n\n  /**\n   * Load balancer this listener is associated with\n   */\n  public readonly loadBalancer: IApplicationLoadBalancer;\n\n  /**\n   * The port of the listener.\n   */\n  public readonly port: number;\n\n  /**\n   * ARNs of certificates added to this listener\n   */\n  private readonly certificateArns: string[];\n\n  /**\n   * Listener protocol for this listener.\n   */\n  private readonly protocol: ApplicationProtocol;\n\n  constructor(scope: Construct, id: string, props: ApplicationListenerProps) {\n    const [protocol, port] = determineProtocolAndPort(\n      props.protocol,\n      props.port,\n    );\n    if (protocol === undefined || port === undefined) {\n      throw new Error(\"At least one of 'port' or 'protocol' is required\");\n    }\n\n    validateMutualAuthentication(props.mutualAuthentication);\n\n    super(scope, id, {\n      loadBalancerArn: props.loadBalancer.loadBalancerArn,\n      certificateArn: Lazy.stringValue({\n        produce: () =>\n          this.certificateArns.length > 0 ? this.certificateArns[0] : undefined,\n      }),\n      protocol,\n      port,\n      sslPolicy: props.sslPolicy,\n      // https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/lb_listener#mutual_authentication\n      mutualAuthentication:\n        props.mutualAuthentication &&\n        Object.keys(props.mutualAuthentication).length > 0\n          ? {\n              ignoreClientCertificateExpiry:\n                props.mutualAuthentication?.ignoreClientCertificateExpiry,\n              // CFN Default is off\n              // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-mutualauthentication.html#cfn-elasticloadbalancingv2-listener-mutualauthentication-mode\n              mode:\n                props.mutualAuthentication?.mutualAuthenticationMode ??\n                MutualAuthenticationMode.OFF,\n              trustStoreArn:\n                props.mutualAuthentication?.trustStore?.trustStoreArn,\n            }\n          : undefined,\n    });\n\n    this.loadBalancer = props.loadBalancer;\n    this.protocol = protocol;\n    this.port = port;\n    this.certificateArns = [];\n\n    // Attach certificates\n    if (props.certificateArns && props.certificateArns.length > 0) {\n      this.addCertificateArns(\"ListenerCertificate\", props.certificateArns);\n    }\n    if (props.certificates && props.certificates.length > 0) {\n      this.addCertificates(\"DefaultCertificates\", props.certificates);\n    }\n\n    // This listener edits the securitygroup of the load balancer,\n    // but adds its own default port.\n    this.connections = new Connections({\n      securityGroups: props.loadBalancer.connections.securityGroups,\n      defaultPort: Port.tcp(port),\n    });\n\n    if (props.defaultAction && props.defaultTargetGroups) {\n      throw new Error(\n        \"Specify at most one of 'defaultAction' and 'defaultTargetGroups'\",\n      );\n    }\n\n    if (props.defaultAction) {\n      this.setDefaultAction(props.defaultAction);\n    }\n\n    if (props.defaultTargetGroups) {\n      this.setDefaultAction(ListenerAction.forward(props.defaultTargetGroups));\n    }\n\n    if (props.open !== false) {\n      this.connections.allowDefaultPortFrom(\n        Peer.anyIpv4(),\n        `Allow from anyone on port ${port}`,\n      );\n      // When enabled, the default security group ingress rules will allow IPv6 ingress from anywhere\n      // recommendedValue: true\n      // FeatureFlags.of(this).isEnabled(\n      //   cxapi.ALB_DUALSTACK_WITHOUT_PUBLIC_IPV4_SECURITY_GROUP_RULES_DEFAULT,\n      // )\n      if (\n        this.loadBalancer.ipAddressType === IpAddressType.DUAL_STACK ||\n        this.loadBalancer.ipAddressType ===\n          IpAddressType.DUAL_STACK_WITHOUT_PUBLIC_IPV4\n      ) {\n        this.connections.allowDefaultPortFrom(\n          Peer.anyIpv6(),\n          `Allow from anyone on port ${port}`,\n        );\n      }\n    }\n  }\n\n  /**\n   * Add one or more certificates to this listener.\n   *\n   * After the first certificate, this creates ApplicationListenerCertificates\n   * resources since cloudformation requires the certificates array on the\n   * listener resource to have a length of 1.\n   *\n   * @deprecated Use `addCertificates` instead.\n   */\n  public addCertificateArns(id: string, arns: string[]): void {\n    this.addCertificates(id, arns.map(ListenerCertificate.fromArn));\n  }\n\n  /**\n   * Add one or more certificates to this listener.\n   *\n   * After the first certificate, this creates ApplicationListenerCertificates\n   * resources since cloudformation requires the certificates array on the\n   * listener resource to have a length of 1.\n   */\n  public addCertificates(\n    id: string,\n    certificates: IListenerCertificate[],\n  ): void {\n    const additionalCerts = [...certificates];\n\n    if (this.certificateArns.length === 0 && additionalCerts.length > 0) {\n      const first = additionalCerts.splice(0, 1)[0];\n      this.certificateArns.push(first.certificateArn);\n    }\n\n    // Only one certificate can be specified per resource, even though\n    // `certificates` is of type Array\n    for (let i = 0; i < additionalCerts.length; i++) {\n      new ApplicationListenerCertificate(this, `${id}${i + 1}`, {\n        listener: this,\n        certificates: [additionalCerts[i]],\n      });\n    }\n  }\n\n  /**\n   * Perform the given default action on incoming requests\n   *\n   * This allows full control of the default action of the load balancer,\n   * including Action chaining, fixed responses and redirect responses. See\n   * the `ListenerAction` class for all options.\n   *\n   * It's possible to add routing conditions to the Action added in this way.\n   * At least one Action must be added without conditions (which becomes the\n   * default Action).\n   */\n  public addAction(id: string, props: AddApplicationActionProps): void {\n    checkAddRuleProps(props);\n\n    if (props.priority !== undefined) {\n      // New rule\n      //\n      // TargetGroup.registerListener is called inside ApplicationListenerRule.\n      new ApplicationListenerRule(this, id + \"Rule\", {\n        listener: this,\n        priority: props.priority,\n        ...props,\n      });\n    } else {\n      // New default target with these targetgroups\n      this.setDefaultAction(props.action);\n    }\n  }\n\n  /**\n   * Load balance incoming requests to the given target groups.\n   *\n   * All target groups will be load balanced to with equal weight and without\n   * stickiness. For a more complex configuration than that, use `addAction()`.\n   *\n   * It's possible to add routing conditions to the TargetGroups added in this\n   * way. At least one TargetGroup must be added without conditions (which will\n   * become the default Action for this listener).\n   */\n  public addTargetGroups(\n    id: string,\n    props: AddApplicationTargetGroupsProps,\n  ): void {\n    checkAddRuleProps(props);\n\n    if (props.priority !== undefined) {\n      // New rule\n      //\n      // TargetGroup.registerListener is called inside ApplicationListenerRule.\n      new ApplicationListenerRule(this, id + \"Rule\", {\n        listener: this,\n        priority: props.priority,\n        ...props,\n      });\n    } else {\n      // New default target with these targetgroups\n      this.setDefaultAction(ListenerAction.forward(props.targetGroups));\n    }\n  }\n\n  /**\n   * Load balance incoming requests to the given load balancing targets.\n   *\n   * This method implicitly creates an ApplicationTargetGroup for the targets\n   * involved, and a 'forward' action to route traffic to the given TargetGroup.\n   *\n   * If you want more control over the precise setup, create the TargetGroup\n   * and use `addAction` yourself.\n   *\n   * It's possible to add conditions to the targets added in this way. At least\n   * one set of targets must be added without conditions.\n   *\n   * @returns The newly created target group\n   */\n  public addTargets(\n    id: string,\n    props: AddApplicationTargetsProps,\n  ): ApplicationTargetGroup {\n    if (!this.loadBalancer.vpc) {\n      // eslint-disable-next-line max-len\n      throw new Error(\n        \"Can only call addTargets() when using a constructed Load Balancer or an imported Load Balancer with specified vpc; construct a new TargetGroup and use addTargetGroup\",\n      );\n    }\n\n    const group = new ApplicationTargetGroup(this, id + \"Group\", {\n      vpc: this.loadBalancer.vpc,\n      ...props,\n    });\n\n    this.addTargetGroups(id, {\n      targetGroups: [group],\n      ...props,\n    });\n\n    return group;\n  }\n\n  /**\n   * Add a fixed response\n   *\n   * @deprecated Use `addAction()` instead\n   */\n  public addFixedResponse(id: string, props: AddFixedResponseProps) {\n    checkAddRuleProps(props);\n\n    const fixedResponse: FixedResponse = {\n      statusCode: props.statusCode,\n      contentType: props.contentType ?? ContentType.TEXT_PLAIN,\n      messageBody: props.messageBody,\n    };\n\n    /**\n     * NOTE - Copy/pasted from `application-listener-rule.ts#validateFixedResponse`.\n     * This was previously a deprecated, exported function, which caused issues with jsii's strip-deprecated functionality.\n     * Inlining the duplication functionality in v2 only (for now).\n     */\n    if (\n      fixedResponse.statusCode &&\n      !/^(2|4|5)\\d\\d$/.test(fixedResponse.statusCode)\n    ) {\n      throw new Error(\"`statusCode` must be 2XX, 4XX or 5XX.\");\n    }\n\n    if (fixedResponse.messageBody && fixedResponse.messageBody.length > 1024) {\n      throw new Error(\"`messageBody` cannot have more than 1024 characters.\");\n    }\n\n    if (props.priority) {\n      new ApplicationListenerRule(this, id + \"Rule\", {\n        listener: this,\n        priority: props.priority,\n        fixedResponse,\n        ...props,\n      });\n    } else {\n      this.setDefaultAction(\n        ListenerAction.fixedResponse(Token.asNumber(props.statusCode), {\n          contentType: props.contentType ?? ContentType.TEXT_PLAIN,\n          messageBody: props.messageBody,\n        }),\n      );\n    }\n  }\n\n  /**\n   * Add a redirect response\n   *\n   * @deprecated Use `addAction()` instead\n   */\n  public addRedirectResponse(id: string, props: AddRedirectResponseProps) {\n    checkAddRuleProps(props);\n    const redirectResponse = {\n      host: props.host,\n      path: props.path,\n      port: props.port,\n      protocol: props.protocol,\n      query: props.query,\n      statusCode: props.statusCode,\n    };\n\n    /**\n     * NOTE - Copy/pasted from `application-listener-rule.ts#validateRedirectResponse`.\n     * This was previously a deprecated, exported function, which caused issues with jsii's strip-deprecated functionality.\n     * Inlining the duplication functionality in v2 only (for now).\n     */\n    if (\n      redirectResponse.protocol &&\n      !/^(HTTPS?|#\\{protocol\\})$/i.test(redirectResponse.protocol)\n    ) {\n      throw new Error(\"`protocol` must be HTTP, HTTPS, or #{protocol}.\");\n    }\n\n    if (\n      !redirectResponse.statusCode ||\n      !/^HTTP_30[12]$/.test(redirectResponse.statusCode)\n    ) {\n      throw new Error(\"`statusCode` must be HTTP_301 or HTTP_302.\");\n    }\n\n    if (props.priority) {\n      new ApplicationListenerRule(this, id + \"Rule\", {\n        listener: this,\n        priority: props.priority,\n        redirectResponse,\n        ...props,\n      });\n    } else {\n      this.setDefaultAction(\n        ListenerAction.redirect({\n          host: props.host,\n          path: props.path,\n          port: props.port,\n          protocol: props.protocol,\n          query: props.query,\n          permanent: props.statusCode === \"HTTP_301\",\n        }),\n      );\n    }\n  }\n\n  /**\n   * Register that a connectable that has been added to this load balancer.\n   *\n   * Don't call this directly. It is called by ApplicationTargetGroup.\n   */\n  public registerConnectable(connectable: IConnectable, portRange: Port): void {\n    connectable.connections.allowFrom(\n      this.loadBalancer,\n      portRange,\n      \"Load balancer to target\",\n    );\n  }\n\n  /**\n   * Validate this listener.\n   */\n  protected validateListener(): string[] {\n    const errors = super.validateListener();\n    if (\n      this.protocol === ApplicationProtocol.HTTPS &&\n      this.certificateArns.length === 0\n    ) {\n      errors.push(\n        \"HTTPS Listener needs at least one certificate (call addCertificates)\",\n      );\n    }\n    return errors;\n  }\n\n  /**\n   * Wrapper for _setDefaultAction which does a type-safe bind\n   */\n  private setDefaultAction(action: ListenerAction) {\n    action.bind(this, this);\n    this._setDefaultAction(action);\n  }\n}\n\n/**\n * Properties to reference an existing listener\n */\nexport interface IApplicationListener extends IListener, IConnectable {\n  /**\n   * Add one or more certificates to this listener.\n   * @deprecated use `addCertificates()`\n   */\n  addCertificateArns(id: string, arns: string[]): void;\n\n  /**\n   * Add one or more certificates to this listener.\n   */\n  addCertificates(id: string, certificates: IListenerCertificate[]): void;\n\n  /**\n   * Load balance incoming requests to the given target groups.\n   *\n   * It's possible to add conditions to the TargetGroups added in this way.\n   * At least one TargetGroup must be added without conditions.\n   */\n  addTargetGroups(id: string, props: AddApplicationTargetGroupsProps): void;\n\n  /**\n   * Load balance incoming requests to the given load balancing targets.\n   *\n   * This method implicitly creates an ApplicationTargetGroup for the targets\n   * involved.\n   *\n   * It's possible to add conditions to the targets added in this way. At least\n   * one set of targets must be added without conditions.\n   *\n   * @returns The newly created target group\n   */\n  addTargets(\n    id: string,\n    props: AddApplicationTargetsProps,\n  ): ApplicationTargetGroup;\n\n  /**\n   * Register that a connectable that has been added to this load balancer.\n   *\n   * Don't call this directly. It is called by ApplicationTargetGroup.\n   */\n  registerConnectable(connectable: IConnectable, portRange: Port): void;\n\n  /**\n   * Perform the given action on incoming requests\n   *\n   * This allows full control of the default action of the load balancer,\n   * including Action chaining, fixed responses and redirect responses. See\n   * the `ListenerAction` class for all options.\n   *\n   * It's possible to add routing conditions to the Action added in this way.\n   *\n   * It is not possible to add a default action to an imported IApplicationListener.\n   * In order to add actions to an imported IApplicationListener a `priority`\n   * must be provided.\n   */\n  addAction(id: string, props: AddApplicationActionProps): void;\n}\n\n/**\n * Properties to reference an existing listener\n */\nexport interface ApplicationListenerAttributes {\n  /**\n   * ARN of the listener\n   */\n  readonly listenerArn: string;\n\n  /**\n   * Security group of the load balancer this listener is associated with\n   */\n  readonly securityGroup: ISecurityGroup;\n\n  /**\n   * The default port on which this listener is listening\n   */\n  readonly defaultPort?: number;\n\n  /**\n   * Whether the imported security group allows all outbound traffic or not when\n   * imported using `securityGroupId`\n   *\n   * Unless set to `false`, no egress rules will be added to the security group.\n   *\n   * @default true\n   *\n   * @deprecated use `securityGroup` instead\n   */\n  readonly securityGroupAllowsAllOutbound?: boolean;\n}\n\nabstract class ExternalApplicationListener\n  extends AwsConstructBase\n  implements IApplicationListener\n{\n  /**\n   * Connections object.\n   */\n  public abstract readonly connections: Connections;\n\n  /**\n   * ARN of the listener\n   */\n  public abstract readonly listenerArn: string;\n  public get listenerOutputs(): ListenerOutputs {\n    return {\n      listenerArn: this.listenerArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.listenerOutputs;\n  }\n\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n  }\n\n  /**\n   * Register that a connectable that has been added to this load balancer.\n   *\n   * Don't call this directly. It is called by ApplicationTargetGroup.\n   */\n  public registerConnectable(connectable: IConnectable, portRange: Port): void {\n    this.connections.allowTo(connectable, portRange, \"Load balancer to target\");\n  }\n\n  /**\n   * Add one or more certificates to this listener.\n   * @deprecated use `addCertificates()`\n   */\n  public addCertificateArns(id: string, arns: string[]): void {\n    this.addCertificates(id, arns.map(ListenerCertificate.fromArn));\n  }\n\n  /**\n   * Add one or more certificates to this listener.\n   */\n  public addCertificates(\n    id: string,\n    certificates: IListenerCertificate[],\n  ): void {\n    new ApplicationListenerCertificate(this, id, {\n      listener: this,\n      certificates,\n    });\n  }\n\n  /**\n   * Load balance incoming requests to the given target groups.\n   *\n   * It's possible to add conditions to the TargetGroups added in this way.\n   * At least one TargetGroup must be added without conditions.\n   */\n  public addTargetGroups(\n    id: string,\n    props: AddApplicationTargetGroupsProps,\n  ): void {\n    checkAddRuleProps(props);\n\n    if (props.priority !== undefined) {\n      // New rule\n      new ApplicationListenerRule(this, id, {\n        listener: this,\n        priority: props.priority,\n        ...props,\n      });\n    } else {\n      throw new Error(\n        \"Cannot add default Target Groups to imported ApplicationListener\",\n      );\n    }\n  }\n\n  /**\n   * Load balance incoming requests to the given load balancing targets.\n   *\n   * This method implicitly creates an ApplicationTargetGroup for the targets\n   * involved.\n   *\n   * It's possible to add conditions to the targets added in this way. At least\n   * one set of targets must be added without conditions.\n   *\n   * @returns The newly created target group\n   */\n  public addTargets(\n    _id: string,\n    _props: AddApplicationTargetsProps,\n  ): ApplicationTargetGroup {\n    // eslint-disable-next-line max-len\n    throw new Error(\n      \"Can only call addTargets() when using a constructed ApplicationListener; construct a new TargetGroup and use addTargetGroup.\",\n    );\n  }\n\n  /**\n   * Perform the given action on incoming requests\n   *\n   * This allows full control of the default action of the load balancer,\n   * including Action chaining, fixed responses and redirect responses. See\n   * the `ListenerAction` class for all options.\n   *\n   * It's possible to add routing conditions to the Action added in this way.\n   *\n   * It is not possible to add a default action to an imported IApplicationListener.\n   * In order to add actions to an imported IApplicationListener a `priority`\n   * must be provided.\n   *\n   * If you previously deployed a `ListenerRule` using the `addTargetGroups()` method\n   * and need to migrate to using the more feature rich `addAction()`\n   * method, then you will need to set the `removeRuleSuffixFromLogicalId: true`\n   * property here to avoid having CloudFormation attempt to replace your resource.\n   */\n  public addAction(id: string, props: AddApplicationActionProps): void {\n    checkAddRuleProps(props);\n\n    if (props.priority !== undefined) {\n      const ruleId = props.removeSuffix ? id : id + \"Rule\";\n      // New rule\n      //\n      // TargetGroup.registerListener is called inside ApplicationListenerRule.\n      new ApplicationListenerRule(this, ruleId, {\n        listener: this,\n        priority: props.priority,\n        ...props,\n      });\n    } else {\n      throw new Error(\n        \"priority must be set for actions added to an imported listener\",\n      );\n    }\n  }\n}\n\n/**\n * An imported application listener.\n */\nclass ImportedApplicationListener extends ExternalApplicationListener {\n  public readonly listenerArn: string;\n  public readonly connections: Connections;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: ApplicationListenerAttributes,\n  ) {\n    super(scope, id);\n\n    this.listenerArn = props.listenerArn;\n    const defaultPort =\n      props.defaultPort !== undefined ? Port.tcp(props.defaultPort) : undefined;\n\n    this.connections = new Connections({\n      securityGroups: [props.securityGroup],\n      defaultPort,\n    });\n  }\n}\n\n// TODO: Add Grid Lookup support\n// class LookedUpApplicationListener extends ExternalApplicationListener {\n//   public readonly listenerArn: string;\n//   public readonly connections: Connections;\n\n//   constructor(\n//     scope: Construct,\n//     id: string,\n//     props: cxapi.LoadBalancerListenerContextResponse,\n//   ) {\n//     super(scope, id);\n\n//     this.listenerArn = props.listenerArn;\n//     this.connections = new Connections({\n//       defaultPort: Port.tcp(props.listenerPort),\n//     });\n\n//     for (const securityGroupId of props.securityGroupIds) {\n//       const securityGroup = SecurityGroup.fromLookupById(\n//         this,\n//         `SecurityGroup-${securityGroupId}`,\n//         securityGroupId,\n//       );\n//       this.connections.addSecurityGroup(securityGroup);\n//     }\n//   }\n// }\n\n/**\n * Properties for adding a conditional load balancing rule\n */\nexport interface AddRuleProps {\n  /**\n   * Priority of this target group\n   *\n   * The rule with the lowest priority will be used for every request.\n   * If priority is not given, these target groups will be added as\n   * defaults, and must not have conditions.\n   *\n   * Priorities must be unique.\n   *\n   * @default Target groups are used as defaults\n   */\n  readonly priority?: number;\n\n  /**\n   * Rule applies if matches the conditions.\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html\n   *\n   * @default - No conditions.\n   */\n  readonly conditions?: ListenerCondition[];\n\n  /**\n   * Rule applies if the requested host matches the indicated host\n   *\n   * May contain up to three '*' wildcards.\n   *\n   * Requires that priority is set.\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#host-conditions\n   *\n   * @default No host condition\n   * @deprecated Use `conditions` instead.\n   */\n  readonly hostHeader?: string;\n\n  /**\n   * Rule applies if the requested path matches the given path pattern\n   *\n   * May contain up to three '*' wildcards.\n   *\n   * Requires that priority is set.\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#path-conditions\n   * @default No path condition\n   * @deprecated Use `conditions` instead.\n   */\n  readonly pathPattern?: string;\n\n  /**\n   * Rule applies if the requested path matches any of the given patterns.\n   *\n   * May contain up to three '*' wildcards.\n   *\n   * Requires that priority is set.\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#path-conditions\n   * @default - No path condition.\n   * @deprecated Use `conditions` instead.\n   */\n  readonly pathPatterns?: string[];\n}\n\n/**\n * Properties for adding a new target group to a listener\n */\nexport interface AddApplicationTargetGroupsProps extends AddRuleProps {\n  /**\n   * Target groups to forward requests to\n   */\n  readonly targetGroups: IApplicationTargetGroup[];\n}\n\n/**\n * Properties for adding a new action to a listener\n */\nexport interface AddApplicationActionProps extends AddRuleProps {\n  /**\n   * Action to perform\n   */\n  readonly action: ListenerAction;\n  /**\n   * `ListenerRule`s have a `Rule` suffix on their logicalId by default. This allows you to remove that suffix.\n   *\n   * Legacy behavior of the `addTargetGroups()` convenience method did not include the `Rule` suffix on the logicalId of the generated `ListenerRule`.\n   * At some point, increasing complexity of requirements can require users to switch from the `addTargetGroups()` method\n   * to the `addAction()` method.\n   * When migrating `ListenerRule`s deployed by a legacy version of `addTargetGroups()`,\n   * you will need to enable this flag to avoid changing the logicalId of your resource.\n   * Otherwise Cfn will attempt to replace the `ListenerRule` and fail.\n   *\n   * @default - use standard logicalId with the `Rule` suffix\n   */\n  readonly removeSuffix?: boolean;\n}\n\n/**\n * Properties for adding new targets to a listener\n */\nexport interface AddApplicationTargetsProps extends AddRuleProps {\n  /**\n   * The protocol to use\n   *\n   * @default Determined from port if known\n   */\n  readonly protocol?: ApplicationProtocol;\n\n  /**\n   * The protocol version to use\n   *\n   * @default ApplicationProtocolVersion.HTTP1\n   */\n  readonly protocolVersion?: ApplicationProtocolVersion;\n\n  /**\n   * The port on which the listener listens for requests.\n   *\n   * @default Determined from protocol if known\n   */\n  readonly port?: number;\n\n  /**\n   * The time period during which the load balancer sends a newly registered\n   * target a linearly increasing share of the traffic to the target group.\n   *\n   * The range is 30-900 seconds (15 minutes).\n   *\n   * @default 0\n   */\n  readonly slowStart?: Duration;\n\n  /**\n   * The stickiness cookie expiration period.\n   *\n   * Setting this value enables load balancer stickiness.\n   *\n   * After this period, the cookie is considered stale. The minimum value is\n   * 1 second and the maximum value is 7 days (604800 seconds).\n   *\n   * @default Stickiness disabled\n   */\n  readonly stickinessCookieDuration?: Duration;\n\n  /**\n   * The name of an application-based stickiness cookie.\n   *\n   * Names that start with the following prefixes are not allowed: AWSALB, AWSALBAPP,\n   * and AWSALBTG; they're reserved for use by the load balancer.\n   *\n   * Note: `stickinessCookieName` parameter depends on the presence of `stickinessCookieDuration` parameter.\n   * If `stickinessCookieDuration` is not set, `stickinessCookieName` will be omitted.\n   *\n   * @default - If `stickinessCookieDuration` is set, a load-balancer generated cookie is used. Otherwise, no stickiness is defined.\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/sticky-sessions.html\n   */\n  readonly stickinessCookieName?: string;\n\n  /**\n   * The targets to add to this target group.\n   *\n   * Can be `Instance`, `IPAddress`, or any self-registering load balancing\n   * target. All target must be of the same type.\n   */\n  readonly targets?: IApplicationLoadBalancerTarget[];\n\n  /**\n   * The name of the target group.\n   *\n   * This name must be unique per region per account, can have a maximum of\n   * 32 characters, must contain only alphanumeric characters or hyphens, and\n   * must not begin or end with a hyphen.\n   *\n   * @default Automatically generated\n   */\n  readonly targetGroupName?: string;\n\n  /**\n   * The amount of time for Elastic Load Balancing to wait before deregistering a target.\n   *\n   * The range is 0-3600 seconds.\n   *\n   * @default Duration.minutes(5)\n   */\n  readonly deregistrationDelay?: Duration;\n\n  /**\n   * Health check configuration\n   *\n   * @default - The default value for each property in this configuration varies depending on the target.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-targetgroup.html#aws-resource-elasticloadbalancingv2-targetgroup-properties\n   */\n  readonly healthCheck?: HealthCheck;\n\n  /**\n   * The load balancing algorithm to select targets for routing requests.\n   *\n   * @default round_robin.\n   */\n  readonly loadBalancingAlgorithmType?: TargetGroupLoadBalancingAlgorithmType;\n\n  /**\n   * Indicates whether anomaly mitigation is enabled.\n   *\n   * Only available when `loadBalancingAlgorithmType` is `TargetGroupLoadBalancingAlgorithmType.WEIGHTED_RANDOM`\n   *\n   * @default false\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#automatic-target-weights\n   */\n  readonly enableAnomalyMitigation?: boolean;\n}\n\n/**\n * Properties for adding a fixed response to a listener\n *\n * @deprecated Use `ApplicationListener.addAction` instead.\n */\nexport interface AddFixedResponseProps extends AddRuleProps, FixedResponse {}\n\n/**\n * Properties for adding a redirect response to a listener\n *\n * @deprecated Use `ApplicationListener.addAction` instead.\n */\nexport interface AddRedirectResponseProps\n  extends AddRuleProps,\n    RedirectResponse {}\n\nfunction checkAddRuleProps(props: AddRuleProps) {\n  const conditionsCount = props.conditions?.length || 0;\n  const hasAnyConditions =\n    conditionsCount !== 0 ||\n    props.hostHeader !== undefined ||\n    props.pathPattern !== undefined ||\n    props.pathPatterns !== undefined;\n  const hasPriority = props.priority !== undefined;\n  if (hasAnyConditions !== hasPriority) {\n    throw new Error(\n      \"Setting 'conditions', 'pathPattern' or 'hostHeader' also requires 'priority', and vice versa\",\n    );\n  }\n}\n\nfunction validateMutualAuthentication(\n  mutualAuthentication?: MutualAuthentication,\n): void {\n  if (!mutualAuthentication) {\n    return;\n  }\n\n  const currentMode = mutualAuthentication.mutualAuthenticationMode;\n\n  if (currentMode === MutualAuthenticationMode.VERIFY) {\n    if (!mutualAuthentication.trustStore) {\n      throw new Error(\n        `You must set 'trustStore' when 'mode' is '${MutualAuthenticationMode.VERIFY}'`,\n      );\n    }\n  }\n\n  if (\n    currentMode === MutualAuthenticationMode.OFF ||\n    currentMode === MutualAuthenticationMode.PASS_THROUGH\n  ) {\n    if (mutualAuthentication.trustStore) {\n      throw new Error(\n        `You cannot set 'trustStore' when 'mode' is '${MutualAuthenticationMode.OFF}' or '${MutualAuthenticationMode.PASS_THROUGH}'`,\n      );\n    }\n\n    if (mutualAuthentication.ignoreClientCertificateExpiry !== undefined) {\n      throw new Error(\n        `You cannot set 'ignoreClientCertificateExpiry' when 'mode' is '${MutualAuthenticationMode.OFF}' or '${MutualAuthenticationMode.PASS_THROUGH}'`,\n      );\n    }\n  }\n}\n"]}