terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/lb-shared/load-balancer-targets.js

@@ -0,0 +1,127 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpTarget = exports.InstanceTarget = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const enums_1 = require("./enums");
+/**
+ * An EC2 instance that is the target for load balancing
+ *
+ * If you register a target of this type, you are responsible for making
+ * sure the load balancer's security group can connect to the instance.
+ *
+ * @deprecated Use IpTarget from the compute/lb-targets instead.
+ */
+class InstanceTarget {
+    /**
+     * Create a new Instance target
+     *
+     * @param instanceId Instance ID of the instance to register to
+     * @param port Override the default port for the target group
+     */
+    constructor(instanceId, port) {
+        this.instanceId = instanceId;
+        this.port = port;
+    }
+    /**
+     * Register this instance target with a load balancer
+     *
+     * Don't call this, it is called automatically when you add the target to a
+     * load balancer.
+     */
+    attachToApplicationTargetGroup(targetGroup) {
+        return this.attach(targetGroup);
+    }
+    /**
+     * Register this instance target with a load balancer
+     *
+     * Don't call this, it is called automatically when you add the target to a
+     * load balancer.
+     */
+    attachToNetworkTargetGroup(targetGroup) {
+        return this.attach(targetGroup);
+    }
+    attach(_targetGroup) {
+        return {
+            targetType: enums_1.TargetType.INSTANCE,
+            targetJson: { targetId: this.instanceId, port: this.port },
+        };
+    }
+}
+exports.InstanceTarget = InstanceTarget;
+_a = JSII_RTTI_SYMBOL_1;
+InstanceTarget[_a] = { fqn: "terraconstructs.aws.compute.InstanceTarget", version: "0.0.12" };
+/**
+ * An IP address that is a target for load balancing.
+ *
+ * Specify IP addresses from the subnets of the virtual private cloud (VPC) for
+ * the target group, the RFC 1918 range (10.0.0.0/8, 172.16.0.0/12, and
+ * 192.168.0.0/16), and the RFC 6598 range (100.64.0.0/10). You can't specify
+ * publicly routable IP addresses.
+ *
+ * If you register a target of this type, you are responsible for making
+ * sure the load balancer's security group can send packets to the IP address.
+ *
+ * @deprecated Use IpTarget from the compute/lb-targets package instead.
+ */
+class IpTarget {
+    /**
+     * Create a new IPAddress target
+     *
+     * The availabilityZone parameter determines whether the target receives
+     * traffic from the load balancer nodes in the specified Availability Zone
+     * or from all enabled Availability Zones for the load balancer.
+     *
+     * This parameter is not supported if the target type of the target group
+     * is instance. If the IP address is in a subnet of the VPC for the target
+     * group, the Availability Zone is automatically detected and this
+     * parameter is optional. If the IP address is outside the VPC, this
+     * parameter is required.
+     *
+     * With an Application Load Balancer, if the IP address is outside the VPC
+     * for the target group, the only supported value is all.
+     *
+     * Default is automatic.
+     *
+     * @param ipAddress The IP Address to load balance to
+     * @param port Override the group's default port
+     * @param availabilityZone Availability zone to send traffic from
+     */
+    constructor(ipAddress, port, availabilityZone) {
+        this.ipAddress = ipAddress;
+        this.port = port;
+        this.availabilityZone = availabilityZone;
+    }
+    /**
+     * Register this instance target with a load balancer
+     *
+     * Don't call this, it is called automatically when you add the target to a
+     * load balancer.
+     */
+    attachToApplicationTargetGroup(targetGroup) {
+        return this.attach(targetGroup);
+    }
+    /**
+     * Register this instance target with a load balancer
+     *
+     * Don't call this, it is called automatically when you add the target to a
+     * load balancer.
+     */
+    attachToNetworkTargetGroup(targetGroup) {
+        return this.attach(targetGroup);
+    }
+    attach(_targetGroup) {
+        return {
+            targetType: enums_1.TargetType.IP,
+            targetJson: {
+                targetId: this.ipAddress,
+                port: this.port,
+                availabilityZone: this.availabilityZone,
+            },
+        };
+    }
+}
+exports.IpTarget = IpTarget;
+_b = JSII_RTTI_SYMBOL_1;
+IpTarget[_b] = { fqn: "terraconstructs.aws.compute.IpTarget", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"load-balancer-targets.js","sourceRoot":"","sources":["../../../../src/aws/compute/lb-shared/load-balancer-targets.ts"],"names":[],"mappings":";;;;;AAGA,mCAAqC;AAUrC;;;;;;;GAOG;AACH,MAAa,cAAc;IAGzB;;;;;OAKG;IACH,YACmB,UAAkB,EAClB,IAAa;QADb,eAAU,GAAV,UAAU,CAAQ;QAClB,SAAI,GAAJ,IAAI,CAAS;IAC7B,CAAC;IAEJ;;;;;OAKG;IACI,8BAA8B,CACnC,WAAoC;QAEpC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACI,0BAA0B,CAC/B,WAAgC;QAEhC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAEO,MAAM,CAAC,YAA0B;QACvC,OAAO;YACL,UAAU,EAAE,kBAAU,CAAC,QAAQ;YAC/B,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE;SAC3D,CAAC;IACJ,CAAC;;AA3CH,wCA4CC;;;AAED;;;;;;;;;;;;GAYG;AACH,MAAa,QAAQ;IAGnB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,YACmB,SAAiB,EACjB,IAAa,EACb,gBAAyB;QAFzB,cAAS,GAAT,SAAS,CAAQ;QACjB,SAAI,GAAJ,IAAI,CAAS;QACb,qBAAgB,GAAhB,gBAAgB,CAAS;IACzC,CAAC;IAEJ;;;;;OAKG;IACI,8BAA8B,CACnC,WAAoC;QAEpC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACI,0BAA0B,CAC/B,WAAgC;QAEhC,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IAEO,MAAM,CAAC,YAA0B;QACvC,OAAO;YACL,UAAU,EAAE,kBAAU,CAAC,EAAE;YACzB,UAAU,EAAE;gBACV,QAAQ,EAAE,IAAI,CAAC,SAAS;gBACxB,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;aACxC;SACF,CAAC;IACJ,CAAC;;AAhEH,4BAiEC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/shared/load-balancer-targets.ts\n\nimport { ITargetGroup, LoadBalancerTargetProps } from \"./base-target-group\";\nimport { TargetType } from \"./enums\";\nimport {\n  IApplicationLoadBalancerTarget,\n  IApplicationTargetGroup,\n} from \"../alb/application-target-group\";\nimport {\n  INetworkLoadBalancerTarget,\n  INetworkTargetGroup,\n} from \"../nlb/network-target-group\";\n\n/**\n * An EC2 instance that is the target for load balancing\n *\n * If you register a target of this type, you are responsible for making\n * sure the load balancer's security group can connect to the instance.\n *\n * @deprecated Use IpTarget from the compute/lb-targets instead.\n */\nexport class InstanceTarget\n  implements IApplicationLoadBalancerTarget, INetworkLoadBalancerTarget\n{\n  /**\n   * Create a new Instance target\n   *\n   * @param instanceId Instance ID of the instance to register to\n   * @param port Override the default port for the target group\n   */\n  constructor(\n    private readonly instanceId: string,\n    private readonly port?: number,\n  ) {}\n\n  /**\n   * Register this instance target with a load balancer\n   *\n   * Don't call this, it is called automatically when you add the target to a\n   * load balancer.\n   */\n  public attachToApplicationTargetGroup(\n    targetGroup: IApplicationTargetGroup,\n  ): LoadBalancerTargetProps {\n    return this.attach(targetGroup);\n  }\n\n  /**\n   * Register this instance target with a load balancer\n   *\n   * Don't call this, it is called automatically when you add the target to a\n   * load balancer.\n   */\n  public attachToNetworkTargetGroup(\n    targetGroup: INetworkTargetGroup,\n  ): LoadBalancerTargetProps {\n    return this.attach(targetGroup);\n  }\n\n  private attach(_targetGroup: ITargetGroup): LoadBalancerTargetProps {\n    return {\n      targetType: TargetType.INSTANCE,\n      targetJson: { targetId: this.instanceId, port: this.port },\n    };\n  }\n}\n\n/**\n * An IP address that is a target for load balancing.\n *\n * Specify IP addresses from the subnets of the virtual private cloud (VPC) for\n * the target group, the RFC 1918 range (10.0.0.0/8, 172.16.0.0/12, and\n * 192.168.0.0/16), and the RFC 6598 range (100.64.0.0/10). You can't specify\n * publicly routable IP addresses.\n *\n * If you register a target of this type, you are responsible for making\n * sure the load balancer's security group can send packets to the IP address.\n *\n * @deprecated Use IpTarget from the compute/lb-targets package instead.\n */\nexport class IpTarget\n  implements IApplicationLoadBalancerTarget, INetworkLoadBalancerTarget\n{\n  /**\n   * Create a new IPAddress target\n   *\n   * The availabilityZone parameter determines whether the target receives\n   * traffic from the load balancer nodes in the specified Availability Zone\n   * or from all enabled Availability Zones for the load balancer.\n   *\n   * This parameter is not supported if the target type of the target group\n   * is instance. If the IP address is in a subnet of the VPC for the target\n   * group, the Availability Zone is automatically detected and this\n   * parameter is optional. If the IP address is outside the VPC, this\n   * parameter is required.\n   *\n   * With an Application Load Balancer, if the IP address is outside the VPC\n   * for the target group, the only supported value is all.\n   *\n   * Default is automatic.\n   *\n   * @param ipAddress The IP Address to load balance to\n   * @param port Override the group's default port\n   * @param availabilityZone Availability zone to send traffic from\n   */\n  constructor(\n    private readonly ipAddress: string,\n    private readonly port?: number,\n    private readonly availabilityZone?: string,\n  ) {}\n\n  /**\n   * Register this instance target with a load balancer\n   *\n   * Don't call this, it is called automatically when you add the target to a\n   * load balancer.\n   */\n  public attachToApplicationTargetGroup(\n    targetGroup: IApplicationTargetGroup,\n  ): LoadBalancerTargetProps {\n    return this.attach(targetGroup);\n  }\n\n  /**\n   * Register this instance target with a load balancer\n   *\n   * Don't call this, it is called automatically when you add the target to a\n   * load balancer.\n   */\n  public attachToNetworkTargetGroup(\n    targetGroup: INetworkTargetGroup,\n  ): LoadBalancerTargetProps {\n    return this.attach(targetGroup);\n  }\n\n  private attach(_targetGroup: ITargetGroup): LoadBalancerTargetProps {\n    return {\n      targetType: TargetType.IP,\n      targetJson: {\n        targetId: this.ipAddress,\n        port: this.port,\n        availabilityZone: this.availabilityZone,\n      },\n    };\n  }\n}\n"]}

package/lib/aws/compute/lb-shared/util.d.ts

@@ -0,0 +1,113 @@
+import { ApplicationProtocol, LbProtocol } from "./enums";
+export type Attributes = {
+    [key: string]: string | undefined;
+};
+export declare const NO_LOADBALANCER_ARNS = "NO_LOADBALANCER_ARNS";
+/**
+ * Render an attribute dict to a list of { key, value } pairs
+ */
+export declare function renderAttributes(attributes: Attributes): any[];
+export declare function lookupStringAttribute(attributes: Attributes, key: string): string | undefined;
+export declare function lookupBoolAttribute(attributes: Attributes, key: string): boolean | undefined;
+export declare function lookupNumberAttribute(attributes: Attributes, key: string): number | undefined;
+/**
+ * Return the appropriate default port for a given protocol
+ */
+export declare function defaultPortForProtocol(proto: ApplicationProtocol): number;
+/**
+ * Return the appropriate default protocol for a given port
+ */
+export declare function defaultProtocolForPort(port: number): ApplicationProtocol;
+/**
+ * Given a protocol and a port, try to guess the other one if it's undefined
+ */
+export declare function determineProtocolAndPort(protocol: ApplicationProtocol | undefined, port: number | undefined): [ApplicationProtocol | undefined, number | undefined];
+/**
+ * Helper function to default undefined input props
+ */
+export declare function ifUndefined<T>(x: T | undefined, def: T): T;
+/**
+ * Helper function for ensuring network listeners and target groups only accept valid
+ * protocols.
+ */
+export declare function validateNetworkProtocol(protocol: LbProtocol): void;
+export declare function parseLoadBalancerFullName(arn: string): string;
+/**
+ * Transforms:
+ *
+ *   arn:aws:elasticloadbalancing:us-east-1:123456789:targetgroup/my-target-group/da693d633af407a0
+ *
+ * Into:
+ *
+ *   targetgroup/my-target-group/da693d633af407a0
+ */
+export declare function parseTargetGroupFullName(arn: string): string;
+export declare class TargetGroupAttribute {
+    static deregistrationDelayTimeoutSeconds: string;
+    static stickinessEnabled: string;
+    static stickinessType: string;
+    static loadBalancingCrossZoneEnabled: string;
+    static targetGroupHealthDNSFailoverMinimumHealthyTargetsCount: string;
+    static targetGroupHealthDNSFailoverMinimumHealthyTargetsPercentage: string;
+    static targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsCount: string;
+    static targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsPercentage: string;
+    static loadBalancingAlgorithmType: string;
+    static loadBalancingAlgorithmAnomalyMitigation: string;
+    static slowStartDurationSeconds: string;
+    static stickinessAppCookieCookieName: string;
+    static stickinessAppCookieDurationSeconds: string;
+    static stickinessLBCookieDurationSeconds: string;
+    static lambdaMultiValueHeadersEnabled: string;
+    static deregistrationDelayConnectionTerminationEnabled: string;
+    static preserveClientIPEnabled: string;
+    static proxyProtocolV2Enabled: string;
+    static targetHealthStateUnhealthyConnectionTerminationEnabled: string;
+    static targetHealthStateUnhealthyDrainingIntervalSeconds: string;
+    static targetFailoverOnDeregistration: string;
+    static targetFailoverOnUnhealthy: string;
+}
+export declare class LoadBalancerAttribute {
+    static deletionProtectionEnabled: string;
+    static loadBalancingCrossZoneEnabled: string;
+    static accessLogsS3Enabled: string;
+    static accessLogsS3Bucket: string;
+    static accessLogsS3Prefix: string;
+    static iPv6DenyAllIGWTraffic: string;
+    static idleTimeoutTimeoutSeconds: string;
+    static clientKeepAliveSeconds: string;
+    static connectionLogsS3Enabled: string;
+    static connectionLogsS3Bucket: string;
+    static connectionLogsS3Prefix: string;
+    static routingHTTPDesyncMitigationMode: string;
+    static routingHTTPDropInvalidHeaderFieldsEnabled: string;
+    static routingHTTPPreserveHostHeaderEnabled: string;
+    static routingHTTPXAmznTLSVersionAndCipherSuiteEnabled: string;
+    static routingHTTPXFFClientPortEnabled: string;
+    static routingHTTPXFFHeaderProcessingMode: string;
+    static routingHTTP2Enabled: string;
+    static wAFFailOpenEnabled: string;
+    static zonalShiftConfigEnabled: string;
+    static dNSRecordClientRoutingPolicy: string;
+}
+export declare class ListenerAttribute {
+    static tcpIdleTimeoutSeconds: string;
+    static routingHTTPRequestXAmznMtlsClientcertHeaderName: string;
+    static routingHTTPRequestXAmznMtlsClientcertIssuerHeaderName: string;
+    static routingHTTPRequestXAmznMtlsClientcertLeafHeaderName: string;
+    static routingHTTPRequestXAmznMtlsClientcertSerialNumberHeaderName: string;
+    static routingHTTPRequestXAmznMtlsClientcertSubjectHeaderName: string;
+    static routingHTTPRequestXAmznMtlsClientcertValidityHeaderName: string;
+    static routingHTTPRequestXAmznTlsCipherSuiteHeaderName: string;
+    static routingHTTPRequestXAmznTlsVersionHeaderName: string;
+    static routingHTTPResponseAccessControlAllowCredentialsHeaderValue: string;
+    static routingHTTPResponseAccessControlAllowHeadersHeaderValue: string;
+    static routingHTTPResponseAccessControlAllowMethodsHeaderValue: string;
+    static routingHTTPResponseAccessControlAllowOriginHeaderValue: string;
+    static routingHTTPResponseAccessControlExposeHeadersHeaderValue: string;
+    static routingHTTPResponseAccessControlMaxAgeHeaderValue: string;
+    static routingHTTPResponseContentSecurityPolicyHeaderValue: string;
+    static routingHTTPResponseServerEnabled: string;
+    static routingHTTPResponseStrictTransportSecurityHeaderValue: string;
+    static routingHTTPResponseXContentTypeOptionsHeaderValue: string;
+    static routingHTTPResponseXFrameOptionsHeaderValue: string;
+}

package/lib/aws/compute/lb-shared/util.js

@@ -0,0 +1,264 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/shared/util.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerAttribute = exports.LoadBalancerAttribute = exports.TargetGroupAttribute = exports.NO_LOADBALANCER_ARNS = void 0;
+exports.renderAttributes = renderAttributes;
+exports.lookupStringAttribute = lookupStringAttribute;
+exports.lookupBoolAttribute = lookupBoolAttribute;
+exports.lookupNumberAttribute = lookupNumberAttribute;
+exports.defaultPortForProtocol = defaultPortForProtocol;
+exports.defaultProtocolForPort = defaultProtocolForPort;
+exports.determineProtocolAndPort = determineProtocolAndPort;
+exports.ifUndefined = ifUndefined;
+exports.validateNetworkProtocol = validateNetworkProtocol;
+exports.parseLoadBalancerFullName = parseLoadBalancerFullName;
+exports.parseTargetGroupFullName = parseTargetGroupFullName;
+const cdktf_1 = require("cdktf");
+const enums_1 = require("./enums");
+// import * as cxschema from "../../../cloud-assembly-schema";
+const arn_1 = require("../../arn");
+exports.NO_LOADBALANCER_ARNS = "NO_LOADBALANCER_ARNS";
+/**
+ * Render an attribute dict to a list of { key, value } pairs
+ */
+function renderAttributes(attributes) {
+    const ret = [];
+    for (const [key, value] of Object.entries(attributes)) {
+        if (value !== undefined) {
+            ret.push({ key, value });
+        }
+    }
+    return ret;
+}
+function lookupStringAttribute(attributes, key) {
+    return attributes[key];
+}
+function lookupBoolAttribute(attributes, key) {
+    return lookupAttribute(attributes, key, parseBool);
+}
+function lookupNumberAttribute(attributes, key) {
+    return lookupAttribute(attributes, key, parseNumber);
+}
+function lookupAttribute(attributes, key, conversionFn) {
+    return conversionFn(attributes[key]);
+}
+/**
+ * Return the appropriate default port for a given protocol
+ */
+function defaultPortForProtocol(proto) {
+    switch (proto) {
+        case enums_1.ApplicationProtocol.HTTP:
+            return 80;
+        case enums_1.ApplicationProtocol.HTTPS:
+            return 443;
+        default:
+            throw new Error(`Unrecognized protocol: ${proto}`);
+    }
+}
+/**
+ * Return the appropriate default protocol for a given port
+ */
+function defaultProtocolForPort(port) {
+    switch (port) {
+        case 80:
+        case 8000:
+        case 8008:
+        case 8080:
+            return enums_1.ApplicationProtocol.HTTP;
+        case 443:
+        case 8443:
+            return enums_1.ApplicationProtocol.HTTPS;
+        default:
+            throw new Error(`Don't know default protocol for port: ${port}; please supply a protocol`);
+    }
+}
+/**
+ * Given a protocol and a port, try to guess the other one if it's undefined
+ */
+// eslint-disable-next-line max-len
+function determineProtocolAndPort(protocol, port) {
+    if (protocol === undefined && port === undefined) {
+        return [undefined, undefined];
+    }
+    if (protocol === undefined) {
+        protocol = defaultProtocolForPort(port);
+    }
+    if (port === undefined) {
+        port = defaultPortForProtocol(protocol);
+    }
+    return [protocol, port];
+}
+/**
+ * Helper function to default undefined input props
+ */
+function ifUndefined(x, def) {
+    return x ?? def;
+}
+/**
+ * Helper function for ensuring network listeners and target groups only accept valid
+ * protocols.
+ */
+function validateNetworkProtocol(protocol) {
+    const NLB_PROTOCOLS = [
+        enums_1.LbProtocol.TCP,
+        enums_1.LbProtocol.TLS,
+        enums_1.LbProtocol.UDP,
+        enums_1.LbProtocol.TCP_UDP,
+    ];
+    if (NLB_PROTOCOLS.indexOf(protocol) === -1) {
+        throw new Error(`The protocol must be one of ${NLB_PROTOCOLS.join(", ")}. Found ${protocol}`);
+    }
+}
+// /**
+//  * Helper to map a map of tags to cxschema tag format.
+//  * @internal
+//  */
+// export function mapTagMapToCxschema(
+//   tagMap: Record<string, string>,
+// ): cxschema.Tag[] {
+//   return Object.entries(tagMap).map(([key, value]) => ({ key, value }));
+// }
+function parseLoadBalancerFullName(arn) {
+    if (cdktf_1.Token.isUnresolved(arn)) {
+        // Unfortunately it is not possible to use Arn.split() because the ARNs have this shape:
+        //
+        //   arn:...:loadbalancer/net/my-load-balancer/123456
+        //
+        // And the way that Arn.split() handles this situation is not enough to obtain the full name
+        const arnParts = cdktf_1.Fn.split("/", arn);
+        return `${cdktf_1.Fn.element(arnParts, 1)}/${cdktf_1.Fn.element(arnParts, 2)}/${cdktf_1.Fn.element(arnParts, 3)}`;
+    }
+    else {
+        const arnComponents = arn_1.Arn.split(arn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        const resourceName = arnComponents.resourceName;
+        if (!resourceName) {
+            throw new Error(`Provided ARN does not belong to a load balancer: ${arn}`);
+        }
+        return resourceName;
+    }
+}
+/**
+ * Transforms:
+ *
+ *   arn:aws:elasticloadbalancing:us-east-1:123456789:targetgroup/my-target-group/da693d633af407a0
+ *
+ * Into:
+ *
+ *   targetgroup/my-target-group/da693d633af407a0
+ */
+function parseTargetGroupFullName(arn) {
+    const arnComponents = arn_1.Arn.split(arn, arn_1.ArnFormat.NO_RESOURCE_NAME);
+    const resource = arnComponents.resource;
+    if (!resource) {
+        throw new Error(`Provided ARN does not belong to a target group: ${arn}`);
+    }
+    return resource;
+}
+function parseBool(val) {
+    if (val === undefined)
+        return undefined;
+    // TODO: error on invalid values?
+    return val === "true";
+}
+function parseNumber(val) {
+    if (val === undefined)
+        return undefined;
+    const num = parseInt(val, 10);
+    if (Number.isNaN(num)) {
+        throw new Error(`Expected number but got "${val}"`);
+    }
+    return num;
+}
+// See https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_TargetGroupAttribute.html#API_TargetGroupAttribute_Contents.
+// https://github.com/hashicorp/terraform-provider-aws/v5.88.0/main/internal/service/elbv2/const.go#L118
+class TargetGroupAttribute {
+}
+exports.TargetGroupAttribute = TargetGroupAttribute;
+// The following attributes are supported by all load balancers:
+TargetGroupAttribute.deregistrationDelayTimeoutSeconds = "deregistration_delay.timeout_seconds";
+TargetGroupAttribute.stickinessEnabled = "stickiness.enabled";
+TargetGroupAttribute.stickinessType = "stickiness.type";
+// The following attributes are supported by Application Load Balancers and Network Load Balancers:
+TargetGroupAttribute.loadBalancingCrossZoneEnabled = "load_balancing.cross_zone.enabled";
+TargetGroupAttribute.targetGroupHealthDNSFailoverMinimumHealthyTargetsCount = "target_group_health.dns_failover.minimum_healthy_targets.count";
+TargetGroupAttribute.targetGroupHealthDNSFailoverMinimumHealthyTargetsPercentage = "target_group_health.dns_failover.minimum_healthy_targets.percentage";
+TargetGroupAttribute.targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsCount = "target_group_health.unhealthy_state_routing.minimum_healthy_targets.count";
+TargetGroupAttribute.targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsPercentage = "target_group_health.unhealthy_state_routing.minimum_healthy_targets.percentage";
+// The following attributes are supported only if the load balancer is an Application Load Balancer and the target is an instance or an IP address:
+TargetGroupAttribute.loadBalancingAlgorithmType = "load_balancing.algorithm.type";
+TargetGroupAttribute.loadBalancingAlgorithmAnomalyMitigation = "load_balancing.algorithm.anomaly_mitigation";
+TargetGroupAttribute.slowStartDurationSeconds = "slow_start.duration_seconds";
+TargetGroupAttribute.stickinessAppCookieCookieName = "stickiness.app_cookie.cookie_name";
+TargetGroupAttribute.stickinessAppCookieDurationSeconds = "stickiness.app_cookie.duration_seconds";
+TargetGroupAttribute.stickinessLBCookieDurationSeconds = "stickiness.lb_cookie.duration_seconds";
+// The following attribute is supported only if the load balancer is an Application Load Balancer and the target is a Lambda function:
+TargetGroupAttribute.lambdaMultiValueHeadersEnabled = "lambda.multi_value_headers.enabled";
+// The following attributes are supported only by Network Load Balancers:
+TargetGroupAttribute.deregistrationDelayConnectionTerminationEnabled = "deregistration_delay.connection_termination.enabled";
+TargetGroupAttribute.preserveClientIPEnabled = "preserve_client_ip.enabled";
+TargetGroupAttribute.proxyProtocolV2Enabled = "proxy_protocol_v2.enabled";
+TargetGroupAttribute.targetHealthStateUnhealthyConnectionTerminationEnabled = "target_health_state.unhealthy.connection_termination.enabled";
+TargetGroupAttribute.targetHealthStateUnhealthyDrainingIntervalSeconds = "target_health_state.unhealthy.draining_interval_seconds";
+// The following attributes are supported only by Gateway Load Balancers:
+TargetGroupAttribute.targetFailoverOnDeregistration = "target_failover.on_deregistration";
+TargetGroupAttribute.targetFailoverOnUnhealthy = "target_failover.on_unhealthy";
+// See https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_LoadBalancerAttribute.html#API_LoadBalancerAttribute_Contents.
+// https://github.com/hashicorp/terraform-provider-aws/blob/main/internal/service/elbv2/const.go#L32
+class LoadBalancerAttribute {
+}
+exports.LoadBalancerAttribute = LoadBalancerAttribute;
+// The following attributes are supported by all load balancers:
+LoadBalancerAttribute.deletionProtectionEnabled = "deletion_protection.enabled";
+LoadBalancerAttribute.loadBalancingCrossZoneEnabled = "load_balancing.cross_zone.enabled";
+// The following attributes are supported by both Application Load Balancers and Network Load Balancers:
+LoadBalancerAttribute.accessLogsS3Enabled = "access_logs.s3.enabled";
+LoadBalancerAttribute.accessLogsS3Bucket = "access_logs.s3.bucket";
+LoadBalancerAttribute.accessLogsS3Prefix = "access_logs.s3.prefix";
+LoadBalancerAttribute.iPv6DenyAllIGWTraffic = "ipv6.deny_all_igw_traffic";
+// The following attributes are supported by only Application Load Balancers:
+LoadBalancerAttribute.idleTimeoutTimeoutSeconds = "idle_timeout.timeout_seconds";
+LoadBalancerAttribute.clientKeepAliveSeconds = "client_keep_alive.seconds";
+LoadBalancerAttribute.connectionLogsS3Enabled = "connection_logs.s3.enabled";
+LoadBalancerAttribute.connectionLogsS3Bucket = "connection_logs.s3.bucket";
+LoadBalancerAttribute.connectionLogsS3Prefix = "connection_logs.s3.prefix";
+LoadBalancerAttribute.routingHTTPDesyncMitigationMode = "routing.http.desync_mitigation_mode";
+LoadBalancerAttribute.routingHTTPDropInvalidHeaderFieldsEnabled = "routing.http.drop_invalid_header_fields.enabled";
+LoadBalancerAttribute.routingHTTPPreserveHostHeaderEnabled = "routing.http.preserve_host_header.enabled";
+LoadBalancerAttribute.routingHTTPXAmznTLSVersionAndCipherSuiteEnabled = "routing.http.x_amzn_tls_version_and_cipher_suite.enabled";
+LoadBalancerAttribute.routingHTTPXFFClientPortEnabled = "routing.http.xff_client_port.enabled";
+LoadBalancerAttribute.routingHTTPXFFHeaderProcessingMode = "routing.http.xff_header_processing.mode";
+LoadBalancerAttribute.routingHTTP2Enabled = "routing.http2.enabled";
+LoadBalancerAttribute.wAFFailOpenEnabled = "waf.fail_open.enabled";
+LoadBalancerAttribute.zonalShiftConfigEnabled = "zonal_shift.config.enabled";
+// The following attributes are supported by only Network Load Balancers:
+LoadBalancerAttribute.dNSRecordClientRoutingPolicy = "dns_record.client_routing_policy";
+// https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/elbv2/listener.go#L880
+// see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-listenerattribute.html
+class ListenerAttribute {
+}
+exports.ListenerAttribute = ListenerAttribute;
+// Attribute only supported on TCP and GENEVE listeners.
+ListenerAttribute.tcpIdleTimeoutSeconds = "tcp.idle_timeout.seconds";
+// Attributes only supported on HTTPS listeners.
+ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertHeaderName = "routing.http.request.x_amzn_mtls_clientcert.header_name";
+ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertIssuerHeaderName = "routing.http.request.x_amzn_mtls_clientcert_issuer.header_name";
+ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertLeafHeaderName = "routing.http.request.x_amzn_mtls_clientcert_leaf.header_name";
+ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertSerialNumberHeaderName = "routing.http.request.x_amzn_mtls_clientcert_serial_number.header_name";
+ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertSubjectHeaderName = "routing.http.request.x_amzn_mtls_clientcert_subject.header_name";
+ListenerAttribute.routingHTTPRequestXAmznMtlsClientcertValidityHeaderName = "routing.http.request.x_amzn_mtls_clientcert_validity.header_name";
+ListenerAttribute.routingHTTPRequestXAmznTlsCipherSuiteHeaderName = "routing.http.request.x_amzn_tls_cipher_suite.header_name";
+ListenerAttribute.routingHTTPRequestXAmznTlsVersionHeaderName = "routing.http.request.x_amzn_tls_version.header_name";
+// Attributes only supported on HTTPS and HTTPS listeners.
+ListenerAttribute.routingHTTPResponseAccessControlAllowCredentialsHeaderValue = "routing.http.response.access_control_allow_credentials.header_value";
+ListenerAttribute.routingHTTPResponseAccessControlAllowHeadersHeaderValue = "routing.http.response.access_control_allow_headers.header_value";
+ListenerAttribute.routingHTTPResponseAccessControlAllowMethodsHeaderValue = "routing.http.response.access_control_allow_methods.header_value";
+ListenerAttribute.routingHTTPResponseAccessControlAllowOriginHeaderValue = "routing.http.response.access_control_allow_origin.header_value";
+// Attributes only supported on HTTPS listeners.
+ListenerAttribute.routingHTTPResponseAccessControlExposeHeadersHeaderValue = "routing.http.response.access_control_expose_headers.header_value";
+ListenerAttribute.routingHTTPResponseAccessControlMaxAgeHeaderValue = "routing.http.response.access_control_max_age.header_value";
+ListenerAttribute.routingHTTPResponseContentSecurityPolicyHeaderValue = "routing.http.response.content_security_policy.header_value";
+ListenerAttribute.routingHTTPResponseServerEnabled = "routing.http.response.server.enabled";
+ListenerAttribute.routingHTTPResponseStrictTransportSecurityHeaderValue = "routing.http.response.strict_transport_security.header_value";
+ListenerAttribute.routingHTTPResponseXContentTypeOptionsHeaderValue = "routing.http.response.x_content_type_options.header_value";
+ListenerAttribute.routingHTTPResponseXFrameOptionsHeaderValue = "routing.http.response.x_frame_options.header_value";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../src/aws/compute/lb-shared/util.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/shared/util.ts\n\nimport { Fn, Token } from \"cdktf\";\nimport { ApplicationProtocol, LbProtocol } from \"./enums\";\n// import * as cxschema from \"../../../cloud-assembly-schema\";\nimport { Arn, ArnFormat } from \"../../arn\";\n\nexport type Attributes = { [key: string]: string | undefined };\n\nexport const NO_LOADBALANCER_ARNS = \"NO_LOADBALANCER_ARNS\";\n\n/**\n * Render an attribute dict to a list of { key, value } pairs\n */\nexport function renderAttributes(attributes: Attributes) {\n  const ret: any[] = [];\n  for (const [key, value] of Object.entries(attributes)) {\n    if (value !== undefined) {\n      ret.push({ key, value });\n    }\n  }\n  return ret;\n}\n\nexport function lookupStringAttribute(\n  attributes: Attributes,\n  key: string,\n): string | undefined {\n  return attributes[key];\n}\n\nexport function lookupBoolAttribute(\n  attributes: Attributes,\n  key: string,\n): boolean | undefined {\n  return lookupAttribute(attributes, key, parseBool);\n}\n\nexport function lookupNumberAttribute(\n  attributes: Attributes,\n  key: string,\n): number | undefined {\n  return lookupAttribute(attributes, key, parseNumber);\n}\n\nfunction lookupAttribute<T = string>(\n  attributes: Attributes,\n  key: string,\n  conversionFn: (x: string | undefined) => T | undefined,\n): T | undefined {\n  return conversionFn(attributes[key]);\n}\n\n/**\n * Return the appropriate default port for a given protocol\n */\nexport function defaultPortForProtocol(proto: ApplicationProtocol): number {\n  switch (proto) {\n    case ApplicationProtocol.HTTP:\n      return 80;\n    case ApplicationProtocol.HTTPS:\n      return 443;\n    default:\n      throw new Error(`Unrecognized protocol: ${proto}`);\n  }\n}\n\n/**\n * Return the appropriate default protocol for a given port\n */\nexport function defaultProtocolForPort(port: number): ApplicationProtocol {\n  switch (port) {\n    case 80:\n    case 8000:\n    case 8008:\n    case 8080:\n      return ApplicationProtocol.HTTP;\n\n    case 443:\n    case 8443:\n      return ApplicationProtocol.HTTPS;\n\n    default:\n      throw new Error(\n        `Don't know default protocol for port: ${port}; please supply a protocol`,\n      );\n  }\n}\n\n/**\n * Given a protocol and a port, try to guess the other one if it's undefined\n */\n// eslint-disable-next-line max-len\nexport function determineProtocolAndPort(\n  protocol: ApplicationProtocol | undefined,\n  port: number | undefined,\n): [ApplicationProtocol | undefined, number | undefined] {\n  if (protocol === undefined && port === undefined) {\n    return [undefined, undefined];\n  }\n\n  if (protocol === undefined) {\n    protocol = defaultProtocolForPort(port!);\n  }\n  if (port === undefined) {\n    port = defaultPortForProtocol(protocol!);\n  }\n\n  return [protocol, port];\n}\n\n/**\n * Helper function to default undefined input props\n */\nexport function ifUndefined<T>(x: T | undefined, def: T) {\n  return x ?? def;\n}\n\n/**\n * Helper function for ensuring network listeners and target groups only accept valid\n * protocols.\n */\nexport function validateNetworkProtocol(protocol: LbProtocol) {\n  const NLB_PROTOCOLS = [\n    LbProtocol.TCP,\n    LbProtocol.TLS,\n    LbProtocol.UDP,\n    LbProtocol.TCP_UDP,\n  ];\n\n  if (NLB_PROTOCOLS.indexOf(protocol) === -1) {\n    throw new Error(\n      `The protocol must be one of ${NLB_PROTOCOLS.join(\", \")}. Found ${protocol}`,\n    );\n  }\n}\n\n// /**\n//  * Helper to map a map of tags to cxschema tag format.\n//  * @internal\n//  */\n// export function mapTagMapToCxschema(\n//   tagMap: Record<string, string>,\n// ): cxschema.Tag[] {\n//   return Object.entries(tagMap).map(([key, value]) => ({ key, value }));\n// }\n\nexport function parseLoadBalancerFullName(arn: string): string {\n  if (Token.isUnresolved(arn)) {\n    // Unfortunately it is not possible to use Arn.split() because the ARNs have this shape:\n    //\n    //   arn:...:loadbalancer/net/my-load-balancer/123456\n    //\n    // And the way that Arn.split() handles this situation is not enough to obtain the full name\n    const arnParts = Fn.split(\"/\", arn);\n    return `${Fn.element(arnParts, 1)}/${Fn.element(arnParts, 2)}/${Fn.element(arnParts, 3)}`;\n  } else {\n    const arnComponents = Arn.split(arn, ArnFormat.SLASH_RESOURCE_NAME);\n    const resourceName = arnComponents.resourceName;\n    if (!resourceName) {\n      throw new Error(\n        `Provided ARN does not belong to a load balancer: ${arn}`,\n      );\n    }\n    return resourceName;\n  }\n}\n\n/**\n * Transforms:\n *\n *   arn:aws:elasticloadbalancing:us-east-1:123456789:targetgroup/my-target-group/da693d633af407a0\n *\n * Into:\n *\n *   targetgroup/my-target-group/da693d633af407a0\n */\nexport function parseTargetGroupFullName(arn: string): string {\n  const arnComponents = Arn.split(arn, ArnFormat.NO_RESOURCE_NAME);\n  const resource = arnComponents.resource;\n  if (!resource) {\n    throw new Error(`Provided ARN does not belong to a target group: ${arn}`);\n  }\n  return resource;\n}\n\nfunction parseBool(val: string | undefined): boolean | undefined {\n  if (val === undefined) return undefined;\n  // TODO: error on invalid values?\n  return val === \"true\";\n}\n\nfunction parseNumber(val: string | undefined): number | undefined {\n  if (val === undefined) return undefined;\n  const num = parseInt(val, 10);\n  if (Number.isNaN(num)) {\n    throw new Error(`Expected number but got \"${val}\"`);\n  }\n  return num;\n}\n\n// See https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_TargetGroupAttribute.html#API_TargetGroupAttribute_Contents.\n// https://github.com/hashicorp/terraform-provider-aws/v5.88.0/main/internal/service/elbv2/const.go#L118\nexport class TargetGroupAttribute {\n  // The following attributes are supported by all load balancers:\n  static deregistrationDelayTimeoutSeconds: string =\n    \"deregistration_delay.timeout_seconds\";\n  static stickinessEnabled = \"stickiness.enabled\";\n  static stickinessType = \"stickiness.type\";\n\n  // The following attributes are supported by Application Load Balancers and Network Load Balancers:\n  static loadBalancingCrossZoneEnabled = \"load_balancing.cross_zone.enabled\";\n  static targetGroupHealthDNSFailoverMinimumHealthyTargetsCount =\n    \"target_group_health.dns_failover.minimum_healthy_targets.count\";\n  static targetGroupHealthDNSFailoverMinimumHealthyTargetsPercentage =\n    \"target_group_health.dns_failover.minimum_healthy_targets.percentage\";\n  static targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsCount =\n    \"target_group_health.unhealthy_state_routing.minimum_healthy_targets.count\";\n  static targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsPercentage =\n    \"target_group_health.unhealthy_state_routing.minimum_healthy_targets.percentage\";\n\n  // The following attributes are supported only if the load balancer is an Application Load Balancer and the target is an instance or an IP address:\n  static loadBalancingAlgorithmType = \"load_balancing.algorithm.type\";\n  static loadBalancingAlgorithmAnomalyMitigation =\n    \"load_balancing.algorithm.anomaly_mitigation\";\n  static slowStartDurationSeconds = \"slow_start.duration_seconds\";\n  static stickinessAppCookieCookieName = \"stickiness.app_cookie.cookie_name\";\n  static stickinessAppCookieDurationSeconds =\n    \"stickiness.app_cookie.duration_seconds\";\n  static stickinessLBCookieDurationSeconds =\n    \"stickiness.lb_cookie.duration_seconds\";\n\n  // The following attribute is supported only if the load balancer is an Application Load Balancer and the target is a Lambda function:\n  static lambdaMultiValueHeadersEnabled = \"lambda.multi_value_headers.enabled\";\n\n  // The following attributes are supported only by Network Load Balancers:\n  static deregistrationDelayConnectionTerminationEnabled =\n    \"deregistration_delay.connection_termination.enabled\";\n  static preserveClientIPEnabled = \"preserve_client_ip.enabled\";\n  static proxyProtocolV2Enabled = \"proxy_protocol_v2.enabled\";\n  static targetHealthStateUnhealthyConnectionTerminationEnabled =\n    \"target_health_state.unhealthy.connection_termination.enabled\";\n  static targetHealthStateUnhealthyDrainingIntervalSeconds =\n    \"target_health_state.unhealthy.draining_interval_seconds\";\n\n  // The following attributes are supported only by Gateway Load Balancers:\n  static targetFailoverOnDeregistration = \"target_failover.on_deregistration\";\n  static targetFailoverOnUnhealthy = \"target_failover.on_unhealthy\";\n}\n\n// See https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_LoadBalancerAttribute.html#API_LoadBalancerAttribute_Contents.\n// https://github.com/hashicorp/terraform-provider-aws/blob/main/internal/service/elbv2/const.go#L32\nexport class LoadBalancerAttribute {\n  // The following attributes are supported by all load balancers:\n  static deletionProtectionEnabled = \"deletion_protection.enabled\";\n  static loadBalancingCrossZoneEnabled = \"load_balancing.cross_zone.enabled\";\n\n  // The following attributes are supported by both Application Load Balancers and Network Load Balancers:\n  static accessLogsS3Enabled = \"access_logs.s3.enabled\";\n  static accessLogsS3Bucket = \"access_logs.s3.bucket\";\n  static accessLogsS3Prefix = \"access_logs.s3.prefix\";\n  static iPv6DenyAllIGWTraffic = \"ipv6.deny_all_igw_traffic\";\n\n  // The following attributes are supported by only Application Load Balancers:\n  static idleTimeoutTimeoutSeconds = \"idle_timeout.timeout_seconds\";\n  static clientKeepAliveSeconds = \"client_keep_alive.seconds\";\n  static connectionLogsS3Enabled = \"connection_logs.s3.enabled\";\n  static connectionLogsS3Bucket = \"connection_logs.s3.bucket\";\n  static connectionLogsS3Prefix = \"connection_logs.s3.prefix\";\n  static routingHTTPDesyncMitigationMode =\n    \"routing.http.desync_mitigation_mode\";\n  static routingHTTPDropInvalidHeaderFieldsEnabled =\n    \"routing.http.drop_invalid_header_fields.enabled\";\n  static routingHTTPPreserveHostHeaderEnabled =\n    \"routing.http.preserve_host_header.enabled\";\n  static routingHTTPXAmznTLSVersionAndCipherSuiteEnabled =\n    \"routing.http.x_amzn_tls_version_and_cipher_suite.enabled\";\n  static routingHTTPXFFClientPortEnabled =\n    \"routing.http.xff_client_port.enabled\";\n  static routingHTTPXFFHeaderProcessingMode =\n    \"routing.http.xff_header_processing.mode\";\n  static routingHTTP2Enabled = \"routing.http2.enabled\";\n  static wAFFailOpenEnabled = \"waf.fail_open.enabled\";\n  static zonalShiftConfigEnabled = \"zonal_shift.config.enabled\";\n\n  // The following attributes are supported by only Network Load Balancers:\n  static dNSRecordClientRoutingPolicy = \"dns_record.client_routing_policy\";\n}\n\n// https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/elbv2/listener.go#L880\n// see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-listenerattribute.html\nexport class ListenerAttribute {\n  // Attribute only supported on TCP and GENEVE listeners.\n  static tcpIdleTimeoutSeconds = \"tcp.idle_timeout.seconds\";\n\n  // Attributes only supported on HTTPS listeners.\n  static routingHTTPRequestXAmznMtlsClientcertHeaderName =\n    \"routing.http.request.x_amzn_mtls_clientcert.header_name\";\n  static routingHTTPRequestXAmznMtlsClientcertIssuerHeaderName =\n    \"routing.http.request.x_amzn_mtls_clientcert_issuer.header_name\";\n  static routingHTTPRequestXAmznMtlsClientcertLeafHeaderName =\n    \"routing.http.request.x_amzn_mtls_clientcert_leaf.header_name\";\n  static routingHTTPRequestXAmznMtlsClientcertSerialNumberHeaderName =\n    \"routing.http.request.x_amzn_mtls_clientcert_serial_number.header_name\";\n  static routingHTTPRequestXAmznMtlsClientcertSubjectHeaderName =\n    \"routing.http.request.x_amzn_mtls_clientcert_subject.header_name\";\n  static routingHTTPRequestXAmznMtlsClientcertValidityHeaderName =\n    \"routing.http.request.x_amzn_mtls_clientcert_validity.header_name\";\n  static routingHTTPRequestXAmznTlsCipherSuiteHeaderName =\n    \"routing.http.request.x_amzn_tls_cipher_suite.header_name\";\n  static routingHTTPRequestXAmznTlsVersionHeaderName =\n    \"routing.http.request.x_amzn_tls_version.header_name\";\n\n  // Attributes only supported on HTTPS and HTTPS listeners.\n  static routingHTTPResponseAccessControlAllowCredentialsHeaderValue =\n    \"routing.http.response.access_control_allow_credentials.header_value\";\n  static routingHTTPResponseAccessControlAllowHeadersHeaderValue =\n    \"routing.http.response.access_control_allow_headers.header_value\";\n  static routingHTTPResponseAccessControlAllowMethodsHeaderValue =\n    \"routing.http.response.access_control_allow_methods.header_value\";\n  static routingHTTPResponseAccessControlAllowOriginHeaderValue =\n    \"routing.http.response.access_control_allow_origin.header_value\";\n\n  // Attributes only supported on HTTPS listeners.\n  static routingHTTPResponseAccessControlExposeHeadersHeaderValue =\n    \"routing.http.response.access_control_expose_headers.header_value\";\n  static routingHTTPResponseAccessControlMaxAgeHeaderValue =\n    \"routing.http.response.access_control_max_age.header_value\";\n  static routingHTTPResponseContentSecurityPolicyHeaderValue =\n    \"routing.http.response.content_security_policy.header_value\";\n  static routingHTTPResponseServerEnabled =\n    \"routing.http.response.server.enabled\";\n  static routingHTTPResponseStrictTransportSecurityHeaderValue =\n    \"routing.http.response.strict_transport_security.header_value\";\n  static routingHTTPResponseXContentTypeOptionsHeaderValue =\n    \"routing.http.response.x_content_type_options.header_value\";\n  static routingHTTPResponseXFrameOptionsHeaderValue =\n    \"routing.http.response.x_frame_options.header_value\";\n}\n"]}

package/lib/aws/compute/lb-targets/alb-target.d.ts

@@ -0,0 +1,67 @@
+import * as compute from "../";
+/**
+ * A single Application Load Balancer as the target for load balancing.
+ */
+export declare class AlbArnTarget implements compute.INetworkLoadBalancerTarget {
+    private readonly albArn;
+    private readonly port;
+    /**
+     * Create a new alb target.
+     * Note that the ALB must have a listener on the provided target port.
+     *
+     * @param albArn The ARN of the application load balancer to load balance to
+     * @param port The port on which the target is listening
+     */
+    constructor(albArn: string, port: number);
+    /**
+     * Register this alb target with a load balancer
+     *
+     * Don't call this, it is called automatically when you add the target to a
+     * load balancer.
+     */
+    attachToNetworkTargetGroup(targetGroup: compute.INetworkTargetGroup): compute.LoadBalancerTargetProps;
+    /**
+     * @internal
+     */
+    protected _attach(_targetGroup: compute.ITargetGroup): compute.LoadBalancerTargetProps;
+}
+/**
+ * A single Application Load Balancer as the target for load balancing.
+ * @deprecated Use `AlbListenerTarget` instead or
+ * `AlbArnTarget` for an imported load balancer. This target does not automatically
+ * add a dependency between the ALB listener and resulting NLB target group,
+ * without which may cause stack deployments to fail if the NLB target group is provisioned
+ * before the listener has been fully created.
+ */
+export declare class AlbTarget extends AlbArnTarget {
+    /**
+     * @param alb The application load balancer to load balance to
+     * @param port The port on which the target is listening
+     */
+    constructor(alb: compute.IApplicationLoadBalancer, port: number);
+}
+/**
+ * A single Application Load Balancer's listener as the target for load balancing.
+ */
+export declare class AlbListenerTarget extends AlbArnTarget {
+    private albListener;
+    /**
+     * Create a new ALB target.
+     * The associated target group will automatically have a dependency added
+     * against the ALB's listener.
+     *
+     * @param albListener The application load balancer listener to target.
+     */
+    constructor(albListener: compute.ApplicationListener);
+    private attach;
+    /**
+     * Register this ALB target with a load balancer.
+     *
+     * Don't call this, it is called automatically when you add the target to a
+     * load balancer.
+     *
+     * This adds dependency on albListener because creation of ALB listener and NLB can vary during runtime.
+     * More Details on - https://github.com/aws/aws-cdk/issues/17208
+     */
+    attachToNetworkTargetGroup(targetGroup: compute.INetworkTargetGroup): compute.LoadBalancerTargetProps;
+}