terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/lb-shared/base-target-group.js

@@ -0,0 +1,364 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetGroupBase = exports.TargetGroupIpAddressType = void 0;
+exports.loadBalancerNameFromListenerArn = loadBalancerNameFromListenerArn;
+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/shared/base-target-group.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const enums_1 = require("./enums");
+const util_1 = require("./util");
+const arn_1 = require("../../arn");
+const aws_construct_1 = require("../../aws-construct");
+/**
+ * The IP address type of targets registered with a target group
+ */
+var TargetGroupIpAddressType;
+(function (TargetGroupIpAddressType) {
+    /**
+     * IPv4 addresses
+     */
+    TargetGroupIpAddressType["IPV4"] = "ipv4";
+    /**
+     * IPv6 addresses
+     */
+    TargetGroupIpAddressType["IPV6"] = "ipv6";
+})(TargetGroupIpAddressType || (exports.TargetGroupIpAddressType = TargetGroupIpAddressType = {}));
+/**
+ * Define the target of a load balancer
+ */
+class TargetGroupBase extends aws_construct_1.AwsConstructBase {
+    get targetGroupOutputs() {
+        return {
+            targetGroupArn: this.targetGroupArn,
+            targetGroupFullName: this.targetGroupFullName,
+            targetGroupName: this.targetGroupName,
+            targetGroupLoadBalancerArns: this.targetGroupLoadBalancerArns,
+            firstLoadBalancerFullName: this.firstLoadBalancerFullName,
+        };
+    }
+    get outputs() {
+        return this.targetGroupOutputs;
+    }
+    /**
+     * @param additionalProps healthCheck, stickiness, targetGroupHealth are controlled by methods and ignored
+     */
+    constructor(scope, id, baseProps, additionalProps) {
+        super(scope, id, baseProps);
+        /**
+         * Configurable dependable with all resources that lead to load balancer attachment
+         */
+        this.loadBalancerAttachedDependencies = new constructs_1.DependencyGroup();
+        /**
+         * Attributes of this target group
+         */
+        this.attributes = {};
+        /**
+         * The JSON objects returned by the directly registered members of this target group
+         */
+        this.targetsJson = new Array();
+        // TODO: Must not begin or end with a hyphen
+        const targetGroupName = baseProps.targetGroupName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+                allowedSpecialCharacters: "-",
+                maxLength: 32,
+            });
+        if (baseProps.deregistrationDelay !== undefined) {
+            this.setAttribute(util_1.TargetGroupAttribute.deregistrationDelayTimeoutSeconds, baseProps.deregistrationDelay.toSeconds().toString());
+        }
+        if (baseProps.crossZoneEnabled !== undefined) {
+            this.setAttribute(util_1.TargetGroupAttribute.loadBalancingCrossZoneEnabled, baseProps.crossZoneEnabled === true ? "true" : "false");
+        }
+        this.healthCheck = baseProps.healthCheck || {};
+        this.vpc = baseProps.vpc;
+        this.targetType = baseProps.targetType;
+        this.resource = new provider_aws_1.lbTargetGroup.LbTargetGroup(this, "Resource", {
+            name: targetGroupName,
+            targetType: cdktf_1.Lazy.stringValue({ produce: () => this.targetType }),
+            vpcId: cdktf_1.Lazy.stringValue({
+                produce: () => this.vpc && this.targetType !== enums_1.TargetType.LAMBDA
+                    ? this.vpc.vpcId
+                    : undefined,
+            }),
+            // Reverse CFN TargetGroupAttributes to Terraform Resource properties
+            // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/elbv2/target_group.go#L800
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-targetgroup-targetgroupattribute.html
+            deregistrationDelay: this.lazyStringAttr(util_1.TargetGroupAttribute.deregistrationDelayTimeoutSeconds),
+            connectionTermination: this.lazyBoolAttr(util_1.TargetGroupAttribute.deregistrationDelayConnectionTerminationEnabled),
+            loadBalancingCrossZoneEnabled: this.lazyStringAttr(util_1.TargetGroupAttribute.loadBalancingCrossZoneEnabled),
+            loadBalancingAlgorithmType: this.lazyStringAttr(util_1.TargetGroupAttribute.loadBalancingAlgorithmType),
+            loadBalancingAnomalyMitigation: this.lazyStringAttr(util_1.TargetGroupAttribute.loadBalancingAlgorithmAnomalyMitigation),
+            slowStart: this.lazyNumberAttr(util_1.TargetGroupAttribute.slowStartDurationSeconds),
+            // stickiness is set in toTerraform as it could be empty object
+            // it is ComplexObject - doesn't work with IResolvable
+            // stickiness: Lazy.anyValue({ ... }),
+            // target_group_health is set in toTerraform as it could be empty object
+            // it is ComplexObject - doesn't work with IResolvable
+            // targetGroupHealth: Lazy.anyValue({ ... }),
+            preserveClientIp: this.lazyStringAttr(util_1.TargetGroupAttribute.preserveClientIPEnabled),
+            proxyProtocolV2: this.lazyBoolAttr(util_1.TargetGroupAttribute.proxyProtocolV2Enabled),
+            lambdaMultiValueHeadersEnabled: this.lazyBoolAttr(util_1.TargetGroupAttribute.lambdaMultiValueHeadersEnabled),
+            targetHealthState: cdktf_1.Lazy.anyValue({
+                produce: () => {
+                    const result = new Array();
+                    const unhealthyDrainingInterval = (0, util_1.lookupNumberAttribute)(this.attributes, util_1.TargetGroupAttribute.targetHealthStateUnhealthyDrainingIntervalSeconds);
+                    const enableUnhealthyConnectionTermination = (0, util_1.lookupBoolAttribute)(this.attributes, util_1.TargetGroupAttribute.targetHealthStateUnhealthyConnectionTerminationEnabled);
+                    if (unhealthyDrainingInterval !== undefined ||
+                        enableUnhealthyConnectionTermination !== undefined) {
+                        result.push({
+                            enableUnhealthyConnectionTermination: enableUnhealthyConnectionTermination ?? true,
+                            unhealthyDrainingInterval,
+                        });
+                    }
+                    return result;
+                },
+            }, { omitEmptyArray: true }),
+            targetFailover: cdktf_1.Lazy.anyValue({
+                produce: () => {
+                    const result = new Array();
+                    const onUnhealthy = (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.targetFailoverOnUnhealthy);
+                    const onDeregistration = (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.targetFailoverOnDeregistration);
+                    // throw error if either is defined without the other
+                    if ((onUnhealthy !== undefined && onDeregistration === undefined) ||
+                        (onUnhealthy === undefined && onDeregistration !== undefined)) {
+                        throw new Error("target_failover.on_unhealthy and target_failover.on_deregistration must be defined together");
+                    }
+                    if (onUnhealthy !== undefined && onDeregistration !== undefined) {
+                        result.push({
+                            onUnhealthy,
+                            onDeregistration,
+                        });
+                    }
+                    return result;
+                },
+            }, { omitEmptyArray: true }),
+            // health_check is set in toTerraform as it could be empty object
+            // it is ComplexObject - doesn't work with IResolvable
+            // healthCheck: Lazy.anyValue({ ...}),
+            ipAddressType: baseProps.ipAddressType,
+            ...additionalProps,
+        });
+        this.targetGroupLoadBalancerArns = this.resource.loadBalancerArns;
+        this.targetGroupArn = this.resource.arn;
+        //this.resource.attrTargetGroupFullName;
+        this.targetGroupFullName = this.stack.splitArn(this.resource.arn, arn_1.ArnFormat.SLASH_RESOURCE_NAME).resource;
+        this.loadBalancerArns = this.resource.loadBalancerArns.toString();
+        this.targetGroupName = this.resource.name;
+        this.defaultPort = additionalProps.port ?? 80; // TODO: This is bug in AWSCDK as it can be undefined.
+        this.protocolVersion = additionalProps?.protocolVersion;
+        this.node.addValidation({ validate: () => this.validateHealthCheck() });
+        this.node.addValidation({ validate: () => this.validateTargetGroup() });
+    }
+    /**
+     * List of constructs that need to be depended on to ensure the TargetGroup is associated to a load balancer
+     */
+    get loadBalancerAttached() {
+        return this.loadBalancerAttachedDependencies;
+    }
+    /**
+     * Set/replace the target group's health check
+     */
+    configureHealthCheck(healthCheck) {
+        this.healthCheck = healthCheck;
+    }
+    /**
+     * AWS CDK specific way of setting non-standard attribute on the target group
+     *
+     * Prefer to use dedicated methods like `configureHealthCheck` or `setAttribute`
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes
+     */
+    setAttribute(key, value) {
+        this.attributes[key] = value;
+    }
+    /**
+     * Register the given load balancing target as part of this group
+     */
+    addLoadBalancerTarget(props) {
+        if (this.targetType !== undefined && this.targetType !== props.targetType) {
+            throw new Error(`Already have a of type '${this.targetType}', adding '${props.targetType}'; make all targets the same type.`);
+        }
+        this.targetType = props.targetType;
+        if (this.targetType === enums_1.TargetType.LAMBDA && this.targetsJson.length >= 1) {
+            throw new Error("TargetGroup can only contain one LAMBDA target. Create a new TargetGroup.");
+        }
+        if (props.targetJson) {
+            this.targetsJson.push(props.targetJson);
+        }
+    }
+    validateTargetGroup() {
+        const ret = new Array();
+        if (this.targetType === undefined && this.targetsJson.length === 0) {
+            // "@aws-cdk/aws-elbv2:targetGroupSpecifyTargetTypeForEmptyTargetGroup",
+            cdktf_1.Annotations.of(this).addWarning("When creating an empty TargetGroup, you should specify a 'targetType' (this warning may become an error in the future).");
+        }
+        if (this.targetType !== enums_1.TargetType.LAMBDA && this.vpc === undefined) {
+            ret.push("'vpc' is required for a non-Lambda TargetGroup");
+        }
+        // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-targetgroup.html#cfn-elasticloadbalancingv2-targetgroup-name
+        const targetGroupName = this.resource.nameInput;
+        if (!cdktf_1.Token.isUnresolved(targetGroupName) && targetGroupName !== undefined) {
+            if (targetGroupName.length > 32) {
+                ret.push(`Target group name: "${targetGroupName}" can have a maximum of 32 characters.`);
+            }
+            if (targetGroupName.startsWith("-") || targetGroupName.endsWith("-")) {
+                ret.push(`Target group name: "${targetGroupName}" must not begin or end with a hyphen.`);
+            }
+            if (!/^[0-9a-z-]+$/i.test(targetGroupName)) {
+                ret.push(`Target group name: "${targetGroupName}" must contain only alphanumeric characters or hyphens.`);
+            }
+        }
+        return ret;
+    }
+    validateHealthCheck() {
+        const ret = new Array();
+        const intervalSeconds = this.healthCheck.interval?.toSeconds();
+        const timeoutSeconds = this.healthCheck.timeout?.toSeconds();
+        if (intervalSeconds && timeoutSeconds) {
+            if (intervalSeconds < timeoutSeconds) {
+                // < instead of <= for backwards compatibility, see discussion in https://github.com/aws/aws-cdk/pull/26031
+                ret.push("Health check interval must be greater than or equal to the timeout; received interval " +
+                    `${intervalSeconds}, timeout ${timeoutSeconds}.`);
+            }
+        }
+        return ret;
+    }
+    lazyStringAttr(key) {
+        return cdktf_1.Lazy.stringValue({
+            produce: () => this.attributes[key],
+        });
+    }
+    lazyBoolAttr(key) {
+        return cdktf_1.Lazy.anyValue({
+            produce: () => (0, util_1.lookupBoolAttribute)(this.attributes, key),
+        });
+    }
+    lazyNumberAttr(key) {
+        return cdktf_1.Lazy.numberValue({
+            produce: () => (0, util_1.lookupNumberAttribute)(this.attributes, key),
+        });
+    }
+    /**
+     * Adds resource to the terraform JSON output.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        // TODO: Switch from provider-aws to provider-awscc and use LazyValue?
+        // instead of inline LazyValue, we use prepareStack() to synth additional resources
+        // targets: Lazy.anyValue(
+        //   { produce: () => this.targetsJson },
+        //   { omitEmptyArray: true },
+        // ),
+        // put putStickiness if attributes are set
+        const stickinessEnabled = (0, util_1.lookupBoolAttribute)(this.attributes, util_1.TargetGroupAttribute.stickinessEnabled);
+        const stickinessAppCookieDuration = (0, util_1.lookupNumberAttribute)(this.attributes, util_1.TargetGroupAttribute.stickinessAppCookieDurationSeconds);
+        const stickinessLBCookieDuration = (0, util_1.lookupNumberAttribute)(this.attributes, util_1.TargetGroupAttribute.stickinessLBCookieDurationSeconds);
+        const stickinessCookieName = (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.stickinessAppCookieCookieName);
+        if ((stickinessEnabled !== undefined && stickinessEnabled !== false) ||
+            stickinessAppCookieDuration !== undefined ||
+            stickinessLBCookieDuration !== undefined ||
+            stickinessCookieName !== undefined) {
+            // possible values for ALB are `lb_cookie` or `app_cookie`
+            // only possible value for NLB is `source_ip`
+            // possible values for GWLB are `source_ip_dest_ip` or `source_ip_dest_ip_proto`
+            const type = (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.stickinessType);
+            // tf requires type to be set
+            if (!type)
+                throw new Error("stickiness.type is required if any stickiness attribute is set");
+            this.resource.putStickiness({
+                type,
+                enabled: (0, util_1.lookupBoolAttribute)(this.attributes, util_1.TargetGroupAttribute.stickinessEnabled),
+                cookieDuration: type === "lb_cookie"
+                    ? stickinessLBCookieDuration
+                    : stickinessAppCookieDuration,
+                // app_cookie attributes
+                cookieName: (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.stickinessAppCookieCookieName),
+            });
+        }
+        /**
+         * The HTTP or gRPC codes to use when checking for a successful response from a target.
+         * The `health_check.protocol` must be one of HTTP or HTTPS or the `target_type` must be lambda.
+         * Values can be comma-separated individual values (e.g., "200,202") or a range of
+         * values (e.g., "200-299").
+         *
+         * - For gRPC-based target groups (i.e., the protocol is one of HTTP or HTTPS and the
+         *   `protocol_version` is GRPC), values can be between 0 and 99. The default is 12.
+         * - When used with an Application Load Balancer (i.e., the protocol is one of HTTP
+         *   or HTTPS and the `protocol_version` is not GRPC), values can be between 200 and 499.
+         *   The default is 200.
+         * - When used with a Network Load Balancer (i.e., the protocol is one of TCP, TCP_UDP, UDP, or TLS),
+         *   values can be between 200 and 599. The default is 200-399.
+         * - When the target_type is lambda, values can be between 200 and 499. The default is 200.
+         *
+         * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/lb_target_group#matcher-1 LbTargetGroup#matcher}
+         */
+        let matcher = this.healthCheck?.healthyHttpCodes;
+        if (this.protocolVersion === "GRPC" &&
+            this.healthCheck?.healthyGrpcCodes !== undefined) {
+            matcher = this.healthCheck.healthyGrpcCodes;
+        }
+        // put HealthCheck if attributes are set
+        this.resource.putHealthCheck({
+            enabled: this.healthCheck?.enabled,
+            interval: this.healthCheck?.interval?.toSeconds(),
+            path: this.healthCheck?.path,
+            port: this.healthCheck?.port,
+            protocol: this.healthCheck?.protocol,
+            timeout: this.healthCheck?.timeout?.toSeconds(),
+            healthyThreshold: this.healthCheck?.healthyThresholdCount,
+            unhealthyThreshold: this.healthCheck?.unhealthyThresholdCount,
+            matcher,
+        });
+        // put targetGroupHealth if attributes are set
+        const dnsFailover = {
+            minimumHealthyTargetsCount: (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.targetGroupHealthDNSFailoverMinimumHealthyTargetsCount),
+            minimumHealthyTargetsPercentage: (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.targetGroupHealthDNSFailoverMinimumHealthyTargetsPercentage),
+        };
+        const unhealthyStateRouting = {
+            minimumHealthyTargetsCount: (0, util_1.lookupNumberAttribute)(this.attributes, util_1.TargetGroupAttribute.targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsCount),
+            minimumHealthyTargetsPercentage: (0, util_1.lookupStringAttribute)(this.attributes, util_1.TargetGroupAttribute.targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsPercentage),
+        };
+        this.resource.putTargetGroupHealth({
+            dnsFailover, // TODO: should be undefined if all object keys are undefined
+            unhealthyStateRouting, // TODO: should be undefined if all object keys are undefined
+        });
+        // add lbTargetGroupAttachment resource for each target
+        for (let i = 0; i < this.targetsJson.length; i++) {
+            const id = `Attachment${i}`;
+            // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag
+            // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48
+            if (this.node.tryFindChild(id))
+                continue; // ignore if already generated
+            new provider_aws_1.lbTargetGroupAttachment.LbTargetGroupAttachment(this, id, {
+                targetGroupArn: this.resource.arn,
+                targetId: this.targetsJson[i].targetId,
+                availabilityZone: this.targetsJson[i].availabilityZone,
+                port: this.targetsJson[i].port,
+            });
+        }
+        return {};
+    }
+}
+exports.TargetGroupBase = TargetGroupBase;
+_a = JSII_RTTI_SYMBOL_1;
+TargetGroupBase[_a] = { fqn: "terraconstructs.aws.compute.TargetGroupBase", version: "0.0.12" };
+/**
+ * Extract the full load balancer name (used for metrics) from the listener ARN:
+ *
+ * Turns
+ *
+ *     arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2
+ *
+ * Into
+ *
+ *     app/my-load-balancer/50dc6c495c0c9188
+ */
+function loadBalancerNameFromListenerArn(listenerArn) {
+    const arnParts = cdktf_1.Fn.split("/", listenerArn);
+    return `${cdktf_1.Fn.element(arnParts, 1)}/${cdktf_1.Fn.element(arnParts, 2)}/${cdktf_1.Fn.element(arnParts, 3)}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-target-group.js","sourceRoot":"","sources":["../../../../src/aws/compute/lb-shared/base-target-group.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/base-target-group.ts\n\nimport {\n  lbTargetGroup as tfTargetGroup,\n  lbTargetGroupAttachment as tfTargetGroupAttachment,\n} from \"@cdktf/provider-aws\";\nimport { Lazy, Token, Fn, Annotations } from \"cdktf\";\nimport {\n  Construct,\n  DependencyGroup,\n  IConstruct,\n  IDependable,\n} from \"constructs\";\nimport { IVpc } from \"../vpc\";\nimport { LbProtocol, TargetType } from \"./enums\";\nimport { LbTargetGroupAttachmentConfig } from \"./lb-target-group-attachment-config.generated\";\nimport {\n  Attributes,\n  lookupStringAttribute,\n  lookupBoolAttribute,\n  lookupNumberAttribute,\n  TargetGroupAttribute as Attribute,\n} from \"./util\";\nimport { Duration } from \"../../../duration\";\nimport { ArnFormat } from \"../../arn\";\nimport {\n  AwsConstructBase,\n  AwsConstructProps,\n  // IAwsConstruct,\n} from \"../../aws-construct\";\n\n/**\n * The IP address type of targets registered with a target group\n */\nexport enum TargetGroupIpAddressType {\n  /**\n   * IPv4 addresses\n   */\n  IPV4 = \"ipv4\",\n\n  /**\n   * IPv6 addresses\n   */\n  IPV6 = \"ipv6\",\n}\n\n/**\n * Basic properties of both Application and Network Target Groups\n */\nexport interface BaseTargetGroupProps extends AwsConstructProps {\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 virtual private cloud (VPC).\n   *\n   * only if `TargetType` is `Ip` or `InstanceId`\n   *\n   * @default - undefined\n   */\n  readonly vpc?: IVpc;\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 300\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 type of targets registered to this TargetGroup, either IP or Instance.\n   *\n   * All targets registered into the group must be of this type. If you\n   * register targets to the TargetGroup in the CDK app, the TargetType is\n   * determined automatically.\n   *\n   * @default - Determined automatically.\n   */\n  readonly targetType?: TargetType;\n\n  /**\n   * Indicates whether cross zone load balancing is enabled.\n   *\n   * @default - use load balancer configuration\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-targetgroup-targetgroupattribute.html\n   */\n  readonly crossZoneEnabled?: boolean;\n\n  /**\n   * The type of IP addresses of the targets registered with the target group.\n   *\n   * @default undefined - ELB defaults to IPv4\n   */\n  readonly ipAddressType?: TargetGroupIpAddressType;\n}\n\n/**\n * Properties for configuring a health check\n */\nexport interface HealthCheck {\n  /**\n   * Indicates whether health checks are enabled. If the target type is lambda,\n   * health checks are disabled by default but can be enabled. If the target type\n   * is instance or ip, health checks are always enabled and cannot be disabled.\n   *\n   * @default - Determined automatically.\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The approximate number of seconds between health checks for an individual target.\n   * Must be 5 to 300 seconds\n   *\n   * @default - 10 seconds if protocol is `GENEVE`, 35 seconds if target type is `lambda`, else 30 seconds\n   */\n  readonly interval?: Duration;\n\n  /**\n   * The ping path destination where Elastic Load Balancing sends health check requests.\n   *\n   * @default /\n   */\n  readonly path?: string;\n\n  /**\n   * The port that the load balancer uses when performing health checks on the targets.\n   *\n   * @default 'traffic-port'\n   */\n  readonly port?: string;\n\n  /**\n   * The protocol the load balancer uses when performing health checks on targets.\n   *\n   * The TCP protocol is supported for health checks only if the protocol of the target group is TCP, TLS, UDP, or TCP_UDP.\n   * The TLS, UDP, and TCP_UDP protocols are not supported for health checks.\n   *\n   * @default - HTTP for ALBs, TCP for NLBs\n   */\n  readonly protocol?: LbProtocol;\n\n  /**\n   * The amount of time, in seconds, during which no response from a target means a failed health check.\n   * Must be 2 to 120 seconds.\n   *\n   * @default - 6 seconds if the protocol is HTTP, 5 seconds if protocol is `GENEVE`, 30 seconds if target type is `lambda`, 10 seconds for TCP, TLS, or HTTPS\n   */\n  readonly timeout?: Duration;\n\n  /**\n   * The number of consecutive health checks successes required before considering an unhealthy target healthy.\n   *\n   * For Application Load Balancers, the default is 5. For Network Load Balancers, the default is 3.\n   *\n   * @default - 5 for ALBs, 3 for NLBs\n   */\n  readonly healthyThresholdCount?: number;\n\n  /**\n   * The number of consecutive health check failures required before considering a target unhealthy.\n   *\n   * For Application Load Balancers, the default is 2. For Network Load\n   * Balancers, the range is between 2-10 and can be set accordingly.\n   *\n   * @default 2\n   */\n  readonly unhealthyThresholdCount?: number;\n\n  /**\n   * GRPC code to use when checking for a successful response from a target.\n   *\n   * You can specify values between 0 and 99. You can specify multiple values\n   * (for example, \"0,1\") or a range of values (for example, \"0-5\").\n   *\n   * @default 12\n   */\n  readonly healthyGrpcCodes?: string;\n\n  /**\n   * HTTP code to use when checking for a successful response from a target.\n   *\n   * For Application Load Balancers, you can specify values between 200 and\n   * 499, and the default value is 200. You can specify multiple values (for\n   * example, \"200,202\") or a range of values (for example, \"200-299\").\n   */\n  readonly healthyHttpCodes?: string;\n}\n\nexport interface TargetGroupOutputs {\n  /**\n   * ARN of the target group\n   */\n  readonly targetGroupArn: string;\n\n  /**\n   * The full name of the target group\n   */\n  readonly targetGroupFullName: string;\n\n  /**\n   * The name of the target group\n   */\n  readonly targetGroupName: string;\n\n  /**\n   * ARNs of load balancers load balancing to this TargetGroup\n   */\n  readonly targetGroupLoadBalancerArns: string[];\n\n  /**\n   * Full name of first load balancer\n   *\n   * This identifier is emitted as a dimensions of the metrics of this target\n   * group.\n   *\n   * Example value: `app/my-load-balancer/123456789`\n   */\n  readonly firstLoadBalancerFullName: string;\n}\n\n/**\n * Define the target of a load balancer\n */\nexport abstract class TargetGroupBase\n  extends AwsConstructBase\n  implements ITargetGroup\n{\n  public get targetGroupOutputs(): TargetGroupOutputs {\n    return {\n      targetGroupArn: this.targetGroupArn,\n      targetGroupFullName: this.targetGroupFullName,\n      targetGroupName: this.targetGroupName,\n      targetGroupLoadBalancerArns: this.targetGroupLoadBalancerArns,\n      firstLoadBalancerFullName: this.firstLoadBalancerFullName,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.targetGroupOutputs;\n  }\n  /**\n   * The ARN of the target group\n   */\n  public readonly targetGroupArn: string;\n\n  /**\n   * The full name of the target group\n   */\n  public readonly targetGroupFullName: string;\n\n  /**\n   * The name of the target group\n   */\n  public readonly targetGroupName: string;\n\n  /**\n   * ARNs of load balancers load balancing to this TargetGroup\n   */\n  public readonly targetGroupLoadBalancerArns: string[];\n\n  /**\n   * Full name of first load balancer\n   *\n   * This identifier is emitted as a dimensions of the metrics of this target\n   * group.\n   *\n   * Example value: `app/my-load-balancer/123456789`\n   */\n  public abstract readonly firstLoadBalancerFullName: string;\n\n  /**\n   * A token representing a list of ARNs of the load balancers that route traffic to this target group\n   */\n  public readonly loadBalancerArns: string;\n\n  /**\n   * Health check for the members of this target group\n   */\n  public healthCheck: HealthCheck;\n\n  /**\n   * Default port configured for members of this target group\n   */\n  protected readonly defaultPort: number;\n\n  /**\n   * Configurable dependable with all resources that lead to load balancer attachment\n   */\n  protected readonly loadBalancerAttachedDependencies = new DependencyGroup();\n\n  /**\n   * The types of the directly registered members of this target group\n   */\n  protected targetType?: TargetType;\n\n  /**\n   * Attributes of this target group\n   */\n  private readonly attributes: Attributes = {};\n\n  /**\n   * The JSON objects returned by the directly registered members of this target group\n   */\n  private readonly targetsJson = new Array<LbTargetGroupAttachmentConfig>();\n\n  /**\n   * The target group VPC\n   *\n   * @default - Required if adding instances instead of Lambdas to TargetGroup\n   */\n  private vpc?: IVpc;\n\n  /**\n   * The protocol version to use\n   *\n   * Only applicable when protocol is HTTP or HTTPS. The protocol version.\n   *\n   * Specify GRPC to send requests to targets using gRPC.\n   * Specify HTTP2 to send requests to targets using HTTP/2.\n   *\n   * The default is HTTP1, which sends requests to targets using HTTP/1.1\n   *\n   * @default \"HTTP1\"\n   */\n  private readonly protocolVersion?: string;\n\n  /**\n   * The target group resource\n   */\n  public readonly resource: tfTargetGroup.LbTargetGroup;\n\n  /**\n   * @param additionalProps healthCheck, stickiness, targetGroupHealth are controlled by methods and ignored\n   */\n  constructor(\n    scope: Construct,\n    id: string,\n    baseProps: BaseTargetGroupProps,\n    additionalProps: tfTargetGroup.LbTargetGroupConfig,\n  ) {\n    super(scope, id, baseProps);\n    // TODO: Must not begin or end with a hyphen\n    const targetGroupName =\n      baseProps.targetGroupName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n        allowedSpecialCharacters: \"-\",\n        maxLength: 32,\n      });\n\n    if (baseProps.deregistrationDelay !== undefined) {\n      this.setAttribute(\n        Attribute.deregistrationDelayTimeoutSeconds,\n        baseProps.deregistrationDelay.toSeconds().toString(),\n      );\n    }\n\n    if (baseProps.crossZoneEnabled !== undefined) {\n      this.setAttribute(\n        Attribute.loadBalancingCrossZoneEnabled,\n        baseProps.crossZoneEnabled === true ? \"true\" : \"false\",\n      );\n    }\n\n    this.healthCheck = baseProps.healthCheck || {};\n    this.vpc = baseProps.vpc;\n    this.targetType = baseProps.targetType;\n\n    this.resource = new tfTargetGroup.LbTargetGroup(this, \"Resource\", {\n      name: targetGroupName,\n      targetType: Lazy.stringValue({ produce: () => this.targetType }),\n      vpcId: Lazy.stringValue({\n        produce: () =>\n          this.vpc && this.targetType !== TargetType.LAMBDA\n            ? this.vpc.vpcId\n            : undefined,\n      }),\n      // Reverse CFN TargetGroupAttributes to Terraform Resource properties\n      // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/elbv2/target_group.go#L800\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-targetgroup-targetgroupattribute.html\n      deregistrationDelay: this.lazyStringAttr(\n        Attribute.deregistrationDelayTimeoutSeconds,\n      ),\n      connectionTermination: this.lazyBoolAttr(\n        Attribute.deregistrationDelayConnectionTerminationEnabled,\n      ),\n      loadBalancingCrossZoneEnabled: this.lazyStringAttr(\n        Attribute.loadBalancingCrossZoneEnabled,\n      ),\n      loadBalancingAlgorithmType: this.lazyStringAttr(\n        Attribute.loadBalancingAlgorithmType,\n      ),\n      loadBalancingAnomalyMitigation: this.lazyStringAttr(\n        Attribute.loadBalancingAlgorithmAnomalyMitigation,\n      ),\n      slowStart: this.lazyNumberAttr(Attribute.slowStartDurationSeconds),\n      // stickiness is set in toTerraform as it could be empty object\n      // it is ComplexObject - doesn't work with IResolvable\n      // stickiness: Lazy.anyValue({ ... }),\n      // target_group_health is set in toTerraform as it could be empty object\n      // it is ComplexObject - doesn't work with IResolvable\n      // targetGroupHealth: Lazy.anyValue({ ... }),\n      preserveClientIp: this.lazyStringAttr(Attribute.preserveClientIPEnabled),\n      proxyProtocolV2: this.lazyBoolAttr(Attribute.proxyProtocolV2Enabled),\n      lambdaMultiValueHeadersEnabled: this.lazyBoolAttr(\n        Attribute.lambdaMultiValueHeadersEnabled,\n      ),\n      targetHealthState: Lazy.anyValue(\n        {\n          produce: () => {\n            const result =\n              new Array<tfTargetGroup.LbTargetGroupTargetHealthState>();\n            const unhealthyDrainingInterval = lookupNumberAttribute(\n              this.attributes,\n              Attribute.targetHealthStateUnhealthyDrainingIntervalSeconds,\n            );\n            const enableUnhealthyConnectionTermination = lookupBoolAttribute(\n              this.attributes,\n              Attribute.targetHealthStateUnhealthyConnectionTerminationEnabled,\n            );\n            if (\n              unhealthyDrainingInterval !== undefined ||\n              enableUnhealthyConnectionTermination !== undefined\n            ) {\n              result.push({\n                enableUnhealthyConnectionTermination:\n                  enableUnhealthyConnectionTermination ?? true,\n                unhealthyDrainingInterval,\n              });\n            }\n            return result;\n          },\n        },\n        { omitEmptyArray: true },\n      ),\n      targetFailover: Lazy.anyValue(\n        {\n          produce: ():\n            | tfTargetGroup.LbTargetGroupTargetFailover[]\n            | undefined => {\n            const result =\n              new Array<tfTargetGroup.LbTargetGroupTargetFailover>();\n            const onUnhealthy = lookupStringAttribute(\n              this.attributes,\n              Attribute.targetFailoverOnUnhealthy,\n            );\n            const onDeregistration = lookupStringAttribute(\n              this.attributes,\n              Attribute.targetFailoverOnDeregistration,\n            );\n            // throw error if either is defined without the other\n            if (\n              (onUnhealthy !== undefined && onDeregistration === undefined) ||\n              (onUnhealthy === undefined && onDeregistration !== undefined)\n            ) {\n              throw new Error(\n                \"target_failover.on_unhealthy and target_failover.on_deregistration must be defined together\",\n              );\n            }\n            if (onUnhealthy !== undefined && onDeregistration !== undefined) {\n              result.push({\n                onUnhealthy,\n                onDeregistration,\n              });\n            }\n            return result;\n          },\n        },\n        { omitEmptyArray: true },\n      ),\n      // health_check is set in toTerraform as it could be empty object\n      // it is ComplexObject - doesn't work with IResolvable\n      // healthCheck: Lazy.anyValue({ ...}),\n      ipAddressType: baseProps.ipAddressType,\n\n      ...additionalProps,\n    });\n\n    this.targetGroupLoadBalancerArns = this.resource.loadBalancerArns;\n    this.targetGroupArn = this.resource.arn;\n    //this.resource.attrTargetGroupFullName;\n    this.targetGroupFullName = this.stack.splitArn(\n      this.resource.arn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    ).resource;\n    this.loadBalancerArns = this.resource.loadBalancerArns.toString();\n    this.targetGroupName = this.resource.name;\n    this.defaultPort = additionalProps.port ?? 80; // TODO: This is bug in AWSCDK as it can be undefined.\n    this.protocolVersion = additionalProps?.protocolVersion;\n\n    this.node.addValidation({ validate: () => this.validateHealthCheck() });\n    this.node.addValidation({ validate: () => this.validateTargetGroup() });\n  }\n\n  /**\n   * List of constructs that need to be depended on to ensure the TargetGroup is associated to a load balancer\n   */\n  public get loadBalancerAttached(): IDependable {\n    return this.loadBalancerAttachedDependencies;\n  }\n\n  /**\n   * Set/replace the target group's health check\n   */\n  public configureHealthCheck(healthCheck: HealthCheck) {\n    this.healthCheck = healthCheck;\n  }\n\n  /**\n   * AWS CDK specific way of setting non-standard attribute on the target group\n   *\n   * Prefer to use dedicated methods like `configureHealthCheck` or `setAttribute`\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-attributes\n   */\n  public setAttribute(key: string, value: string | undefined) {\n    this.attributes[key] = value;\n  }\n\n  /**\n   * Register the given load balancing target as part of this group\n   */\n  protected addLoadBalancerTarget(props: LoadBalancerTargetProps) {\n    if (this.targetType !== undefined && this.targetType !== props.targetType) {\n      throw new Error(\n        `Already have a of type '${this.targetType}', adding '${props.targetType}'; make all targets the same type.`,\n      );\n    }\n    this.targetType = props.targetType;\n\n    if (this.targetType === TargetType.LAMBDA && this.targetsJson.length >= 1) {\n      throw new Error(\n        \"TargetGroup can only contain one LAMBDA target. Create a new TargetGroup.\",\n      );\n    }\n\n    if (props.targetJson) {\n      this.targetsJson.push(props.targetJson);\n    }\n  }\n\n  protected validateTargetGroup(): string[] {\n    const ret = new Array<string>();\n\n    if (this.targetType === undefined && this.targetsJson.length === 0) {\n      // \"@aws-cdk/aws-elbv2:targetGroupSpecifyTargetTypeForEmptyTargetGroup\",\n      Annotations.of(this).addWarning(\n        \"When creating an empty TargetGroup, you should specify a 'targetType' (this warning may become an error in the future).\",\n      );\n    }\n\n    if (this.targetType !== TargetType.LAMBDA && this.vpc === undefined) {\n      ret.push(\"'vpc' is required for a non-Lambda TargetGroup\");\n    }\n\n    // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-targetgroup.html#cfn-elasticloadbalancingv2-targetgroup-name\n    const targetGroupName = this.resource.nameInput;\n    if (!Token.isUnresolved(targetGroupName) && targetGroupName !== undefined) {\n      if (targetGroupName.length > 32) {\n        ret.push(\n          `Target group name: \"${targetGroupName}\" can have a maximum of 32 characters.`,\n        );\n      }\n      if (targetGroupName.startsWith(\"-\") || targetGroupName.endsWith(\"-\")) {\n        ret.push(\n          `Target group name: \"${targetGroupName}\" must not begin or end with a hyphen.`,\n        );\n      }\n      if (!/^[0-9a-z-]+$/i.test(targetGroupName)) {\n        ret.push(\n          `Target group name: \"${targetGroupName}\" must contain only alphanumeric characters or hyphens.`,\n        );\n      }\n    }\n\n    return ret;\n  }\n\n  protected validateHealthCheck(): string[] {\n    const ret = new Array<string>();\n\n    const intervalSeconds = this.healthCheck.interval?.toSeconds();\n    const timeoutSeconds = this.healthCheck.timeout?.toSeconds();\n\n    if (intervalSeconds && timeoutSeconds) {\n      if (intervalSeconds < timeoutSeconds) {\n        // < instead of <= for backwards compatibility, see discussion in https://github.com/aws/aws-cdk/pull/26031\n        ret.push(\n          \"Health check interval must be greater than or equal to the timeout; received interval \" +\n            `${intervalSeconds}, timeout ${timeoutSeconds}.`,\n        );\n      }\n    }\n    return ret;\n  }\n\n  private lazyStringAttr(key: string) {\n    return Lazy.stringValue({\n      produce: () => this.attributes[key],\n    });\n  }\n  private lazyBoolAttr(key: string) {\n    return Lazy.anyValue({\n      produce: () => lookupBoolAttribute(this.attributes, key),\n    });\n  }\n  private lazyNumberAttr(key: string) {\n    return Lazy.numberValue({\n      produce: () => lookupNumberAttribute(this.attributes, key),\n    });\n  }\n\n  /**\n   * Adds resource to the terraform JSON output.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    // TODO: Switch from provider-aws to provider-awscc and use LazyValue?\n    // instead of inline LazyValue, we use prepareStack() to synth additional resources\n    // targets: Lazy.anyValue(\n    //   { produce: () => this.targetsJson },\n    //   { omitEmptyArray: true },\n    // ),\n\n    // put putStickiness if attributes are set\n    const stickinessEnabled = lookupBoolAttribute(\n      this.attributes,\n      Attribute.stickinessEnabled,\n    );\n    const stickinessAppCookieDuration = lookupNumberAttribute(\n      this.attributes,\n      Attribute.stickinessAppCookieDurationSeconds,\n    );\n    const stickinessLBCookieDuration = lookupNumberAttribute(\n      this.attributes,\n      Attribute.stickinessLBCookieDurationSeconds,\n    );\n    const stickinessCookieName = lookupStringAttribute(\n      this.attributes,\n      Attribute.stickinessAppCookieCookieName,\n    );\n    if (\n      (stickinessEnabled !== undefined && stickinessEnabled !== false) ||\n      stickinessAppCookieDuration !== undefined ||\n      stickinessLBCookieDuration !== undefined ||\n      stickinessCookieName !== undefined\n    ) {\n      // possible values for ALB are `lb_cookie` or `app_cookie`\n      // only possible value for NLB is `source_ip`\n      // possible values for GWLB are `source_ip_dest_ip` or `source_ip_dest_ip_proto`\n      const type = lookupStringAttribute(\n        this.attributes,\n        Attribute.stickinessType,\n      );\n      // tf requires type to be set\n      if (!type)\n        throw new Error(\n          \"stickiness.type is required if any stickiness attribute is set\",\n        );\n      this.resource.putStickiness({\n        type,\n        enabled: lookupBoolAttribute(\n          this.attributes,\n          Attribute.stickinessEnabled,\n        ),\n        cookieDuration:\n          type === \"lb_cookie\"\n            ? stickinessLBCookieDuration\n            : stickinessAppCookieDuration,\n        // app_cookie attributes\n        cookieName: lookupStringAttribute(\n          this.attributes,\n          Attribute.stickinessAppCookieCookieName,\n        ),\n      });\n    }\n\n    /**\n     * The HTTP or gRPC codes to use when checking for a successful response from a target.\n     * The `health_check.protocol` must be one of HTTP or HTTPS or the `target_type` must be lambda.\n     * Values can be comma-separated individual values (e.g., \"200,202\") or a range of\n     * values (e.g., \"200-299\").\n     *\n     * - For gRPC-based target groups (i.e., the protocol is one of HTTP or HTTPS and the\n     *   `protocol_version` is GRPC), values can be between 0 and 99. The default is 12.\n     * - When used with an Application Load Balancer (i.e., the protocol is one of HTTP\n     *   or HTTPS and the `protocol_version` is not GRPC), values can be between 200 and 499.\n     *   The default is 200.\n     * - When used with a Network Load Balancer (i.e., the protocol is one of TCP, TCP_UDP, UDP, or TLS),\n     *   values can be between 200 and 599. The default is 200-399.\n     * - When the target_type is lambda, values can be between 200 and 499. The default is 200.\n     *\n     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/lb_target_group#matcher-1 LbTargetGroup#matcher}\n     */\n    let matcher = this.healthCheck?.healthyHttpCodes;\n    if (\n      this.protocolVersion === \"GRPC\" &&\n      this.healthCheck?.healthyGrpcCodes !== undefined\n    ) {\n      matcher = this.healthCheck.healthyGrpcCodes;\n    }\n\n    // put HealthCheck if attributes are set\n    this.resource.putHealthCheck({\n      enabled: this.healthCheck?.enabled,\n      interval: this.healthCheck?.interval?.toSeconds(),\n      path: this.healthCheck?.path,\n      port: this.healthCheck?.port,\n      protocol: this.healthCheck?.protocol,\n      timeout: this.healthCheck?.timeout?.toSeconds(),\n      healthyThreshold: this.healthCheck?.healthyThresholdCount,\n      unhealthyThreshold: this.healthCheck?.unhealthyThresholdCount,\n      matcher,\n    });\n\n    // put targetGroupHealth if attributes are set\n    const dnsFailover: tfTargetGroup.LbTargetGroupTargetGroupHealthDnsFailover =\n      {\n        minimumHealthyTargetsCount: lookupStringAttribute(\n          this.attributes,\n          Attribute.targetGroupHealthDNSFailoverMinimumHealthyTargetsCount,\n        ),\n        minimumHealthyTargetsPercentage: lookupStringAttribute(\n          this.attributes,\n          Attribute.targetGroupHealthDNSFailoverMinimumHealthyTargetsPercentage,\n        ),\n      };\n    const unhealthyStateRouting: tfTargetGroup.LbTargetGroupTargetGroupHealthUnhealthyStateRouting =\n      {\n        minimumHealthyTargetsCount: lookupNumberAttribute(\n          this.attributes,\n          Attribute.targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsCount,\n        ),\n        minimumHealthyTargetsPercentage: lookupStringAttribute(\n          this.attributes,\n          Attribute.targetGroupHealthUnhealthyStateRoutingMinimumHealthyTargetsPercentage,\n        ),\n      };\n    this.resource.putTargetGroupHealth({\n      dnsFailover, // TODO: should be undefined if all object keys are undefined\n      unhealthyStateRouting, // TODO: should be undefined if all object keys are undefined\n    });\n\n    // add lbTargetGroupAttachment resource for each target\n    for (let i = 0; i < this.targetsJson.length; i++) {\n      const id = `Attachment${i}`;\n      // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag\n      // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48\n      if (this.node.tryFindChild(id)) continue; // ignore if already generated\n\n      new tfTargetGroupAttachment.LbTargetGroupAttachment(this, id, {\n        targetGroupArn: this.resource.arn,\n        targetId: this.targetsJson[i].targetId,\n        availabilityZone: this.targetsJson[i].availabilityZone,\n        port: this.targetsJson[i].port,\n      });\n    }\n    return {};\n  }\n}\n\n/**\n * Properties to reference an existing target group\n */\nexport interface TargetGroupAttributes {\n  /**\n   * ARN of the target group\n   */\n  readonly targetGroupArn: string;\n\n  /**\n   * Port target group is listening on\n   *\n   * @deprecated - This property is unused and the wrong type. No need to use it.\n   */\n  readonly defaultPort?: string;\n\n  /**\n   * A Token representing the list of ARNs for the load balancer routing to this target group\n   */\n  readonly loadBalancerArns?: string;\n}\n\n/**\n * Properties to reference an existing target group\n *\n * @deprecated Use TargetGroupAttributes instead\n */\nexport interface TargetGroupImportProps extends TargetGroupAttributes {}\n\n/**\n * A target group\n */\nexport interface ITargetGroup extends IConstruct {\n  // TODO: Extend IAwsConstruct instead?\n  /**\n   * The name of the target group\n   */\n  readonly targetGroupName: string;\n\n  /**\n   * ARN of the target group\n   */\n  readonly targetGroupArn: string;\n\n  /**\n   * A token representing a list of ARNs of the load balancers that route traffic to this target group\n   */\n  readonly loadBalancerArns: string;\n\n  /**\n   * Return an object to depend on the listeners added to this target group\n   */\n  readonly loadBalancerAttached: IDependable;\n}\n\n/**\n * Result of attaching a target to load balancer\n */\nexport interface LoadBalancerTargetProps {\n  /**\n   * What kind of target this is\n   */\n  readonly targetType: TargetType;\n\n  /**\n   * JSON representing the target's direct addition to the TargetGroup list\n   *\n   * May be omitted if the target is going to register itself later.\n   */\n  readonly targetJson?: LbTargetGroupAttachmentConfig;\n}\n\n/**\n * Extract the full load balancer name (used for metrics) from the listener ARN:\n *\n * Turns\n *\n *     arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2\n *\n * Into\n *\n *     app/my-load-balancer/50dc6c495c0c9188\n */\nexport function loadBalancerNameFromListenerArn(listenerArn: string) {\n  const arnParts = Fn.split(\"/\", listenerArn);\n  return `${Fn.element(arnParts, 1)}/${Fn.element(arnParts, 2)}/${Fn.element(arnParts, 3)}`;\n}\n"]}