terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/nlb/network-listener-action.d.ts

@@ -0,0 +1,92 @@
+import { lbListener as tfListener, lbListenerRule as tfListenerRule } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { INetworkListener } from "./network-listener";
+import { INetworkTargetGroup } from "./network-target-group";
+import { Duration } from "../../../duration";
+import { IListenerAction } from "../lb-shared/listener-action";
+/**
+ * What to do when a client makes a request to a listener
+ *
+ * Some actions can be combined with other ones (specifically,
+ * you can perform authentication before serving the request).
+ *
+ * Multiple actions form a linked chain; the chain must always terminate in a
+ * *(weighted)forward*, *fixedResponse* or *redirect* action.
+ *
+ * If an action supports chaining, the next action can be indicated
+ * by passing it in the `next` property.
+ */
+export declare class NetworkListenerAction implements IListenerAction {
+    private readonly defaultActionJson;
+    protected readonly next?: NetworkListenerAction | undefined;
+    /**
+     * Forward to one or more Target Groups
+     */
+    static forward(targetGroups: INetworkTargetGroup[], options?: NetworkForwardOptions): NetworkListenerAction;
+    /**
+     * Forward to one or more Target Groups which are weighted differently
+     */
+    static weightedForward(targetGroups: NetworkWeightedTargetGroup[], options?: NetworkForwardOptions): NetworkListenerAction;
+    private _actionJson?;
+    /**
+     * Create an instance of NetworkListenerAction
+     *
+     * The default class should be good enough for most cases and
+     * should be created by using one of the static factory functions,
+     * but allow overriding to make sure we allow flexibility for the future.
+     */
+    protected constructor(defaultActionJson: tfListener.LbListenerDefaultAction, next?: NetworkListenerAction | undefined);
+    /**
+     * Render the listener rule actions in this chain
+     */
+    renderRuleActions(): tfListenerRule.LbListenerRuleAction[];
+    /**
+     * Render the listener default actions in this chain
+     */
+    renderActions(): tfListener.LbListenerDefaultAction[];
+    /**
+     * Called when the action is being used in a listener
+     */
+    bind(scope: Construct, listener: INetworkListener): void;
+    private _renumber;
+    /**
+     * Renumber the "order" fields in the actions array.
+     *
+     * We don't number for 0 or 1 elements, but otherwise number them 1...#actions
+     * so ELB knows about the right order.
+     *
+     * Do this in `NetworkListenerAction` instead of in `Listener` so that we give
+     * users the opportunity to override by subclassing and overriding `renderActions`.
+     */
+    protected renumber(actions: tfListener.LbListenerDefaultAction[]): tfListener.LbListenerDefaultAction[];
+}
+/**
+ * Options for `NetworkListenerAction.forward()`
+ */
+export interface NetworkForwardOptions {
+    /**
+     * For how long clients should be directed to the same target group
+     *
+     * Range between 1 second and 7 days.
+     *
+     * @default - No stickiness
+     */
+    readonly stickinessDuration?: Duration;
+}
+/**
+ * A Target Group and weight combination
+ */
+export interface NetworkWeightedTargetGroup {
+    /**
+     * The target group
+     */
+    readonly targetGroup: INetworkTargetGroup;
+    /**
+     * The target group's weight
+     *
+     * Range is [0..1000).
+     *
+     * @default 1
+     */
+    readonly weight?: number;
+}

package/lib/aws/compute/nlb/network-listener-action.js

@@ -0,0 +1,146 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkListenerAction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * What to do when a client makes a request to a listener
+ *
+ * Some actions can be combined with other ones (specifically,
+ * you can perform authentication before serving the request).
+ *
+ * Multiple actions form a linked chain; the chain must always terminate in a
+ * *(weighted)forward*, *fixedResponse* or *redirect* action.
+ *
+ * If an action supports chaining, the next action can be indicated
+ * by passing it in the `next` property.
+ */
+class NetworkListenerAction {
+    /**
+     * Forward to one or more Target Groups
+     */
+    static forward(targetGroups, options = {}) {
+        if (targetGroups.length === 0) {
+            throw new Error("Need at least one targetGroup in a NetworkListenerAction.forward()");
+        }
+        if (targetGroups.length === 1 && options.stickinessDuration === undefined) {
+            // Render a "simple" action for backwards compatibility with old templates
+            return new TargetGroupListenerAction(targetGroups, {
+                type: "forward",
+                targetGroupArn: targetGroups[0].targetGroupArn,
+            });
+        }
+        return new TargetGroupListenerAction(targetGroups, {
+            type: "forward",
+            forward: {
+                targetGroup: targetGroups.map((g) => ({
+                    arn: g.targetGroupArn,
+                })),
+                stickiness: options.stickinessDuration
+                    ? {
+                        duration: options.stickinessDuration.toSeconds(),
+                        enabled: true,
+                    }
+                    : undefined,
+            },
+        });
+    }
+    /**
+     * Forward to one or more Target Groups which are weighted differently
+     */
+    static weightedForward(targetGroups, options = {}) {
+        if (targetGroups.length === 0) {
+            throw new Error("Need at least one targetGroup in a NetworkListenerAction.weightedForward()");
+        }
+        return new TargetGroupListenerAction(targetGroups.map((g) => g.targetGroup), {
+            type: "forward",
+            forward: {
+                targetGroup: targetGroups.map((g) => ({
+                    arn: g.targetGroup.targetGroupArn,
+                    weight: g.weight,
+                })),
+                stickiness: options.stickinessDuration
+                    ? {
+                        duration: options.stickinessDuration.toSeconds(),
+                        enabled: true,
+                    }
+                    : undefined,
+            },
+        });
+    }
+    /**
+     * Create an instance of NetworkListenerAction
+     *
+     * The default class should be good enough for most cases and
+     * should be created by using one of the static factory functions,
+     * but allow overriding to make sure we allow flexibility for the future.
+     */
+    constructor(defaultActionJson, next) {
+        this.defaultActionJson = defaultActionJson;
+        this.next = next;
+    }
+    /**
+     * Render the listener rule actions in this chain
+     */
+    renderRuleActions() {
+        const actionJson = this._actionJson ??
+            this.defaultActionJson;
+        return this._renumber([
+            actionJson,
+            ...(this.next?.renderRuleActions() ?? []),
+        ]);
+    }
+    /**
+     * Render the listener default actions in this chain
+     */
+    renderActions() {
+        return this._renumber([
+            this.defaultActionJson,
+            ...(this.next?.renderActions() ?? []),
+        ]);
+    }
+    /**
+     * Called when the action is being used in a listener
+     */
+    bind(scope, listener) {
+        // Empty on purpose
+        Array.isArray(scope);
+        Array.isArray(listener);
+    }
+    _renumber(actions) {
+        if (actions.length < 2) {
+            return actions;
+        }
+        return actions.map((action, i) => ({ ...action, order: i + 1 }));
+    }
+    /**
+     * Renumber the "order" fields in the actions array.
+     *
+     * We don't number for 0 or 1 elements, but otherwise number them 1...#actions
+     * so ELB knows about the right order.
+     *
+     * Do this in `NetworkListenerAction` instead of in `Listener` so that we give
+     * users the opportunity to override by subclassing and overriding `renderActions`.
+     */
+    renumber(actions) {
+        return this._renumber(actions);
+    }
+}
+exports.NetworkListenerAction = NetworkListenerAction;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkListenerAction[_a] = { fqn: "terraconstructs.aws.compute.NetworkListenerAction", version: "0.0.12" };
+/**
+ * Listener Action that calls "registerListener" on TargetGroups
+ */
+class TargetGroupListenerAction extends NetworkListenerAction {
+    constructor(targetGroups, defaultActionJson) {
+        super(defaultActionJson);
+        this.targetGroups = targetGroups;
+    }
+    bind(_scope, listener) {
+        for (const tg of this.targetGroups) {
+            tg.registerListener(listener);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-listener-action.js","sourceRoot":"","sources":["../../../../src/aws/compute/nlb/network-listener-action.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/nlb/network-listener-action.ts\n\nimport {\n  lbListener as tfListener,\n  lbListenerRule as tfListenerRule,\n} from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { INetworkListener } from \"./network-listener\";\nimport { INetworkTargetGroup } from \"./network-target-group\";\nimport { Duration } from \"../../../duration\";\nimport { IListenerAction } from \"../lb-shared/listener-action\";\n\n/**\n * What to do when a client makes a request to a listener\n *\n * Some actions can be combined with other ones (specifically,\n * you can perform authentication before serving the request).\n *\n * Multiple actions form a linked chain; the chain must always terminate in a\n * *(weighted)forward*, *fixedResponse* or *redirect* action.\n *\n * If an action supports chaining, the next action can be indicated\n * by passing it in the `next` property.\n */\nexport class NetworkListenerAction implements IListenerAction {\n  /**\n   * Forward to one or more Target Groups\n   */\n  public static forward(\n    targetGroups: INetworkTargetGroup[],\n    options: NetworkForwardOptions = {},\n  ): NetworkListenerAction {\n    if (targetGroups.length === 0) {\n      throw new Error(\n        \"Need at least one targetGroup in a NetworkListenerAction.forward()\",\n      );\n    }\n    if (targetGroups.length === 1 && options.stickinessDuration === undefined) {\n      // Render a \"simple\" action for backwards compatibility with old templates\n      return new TargetGroupListenerAction(targetGroups, {\n        type: \"forward\",\n        targetGroupArn: targetGroups[0].targetGroupArn,\n      });\n    }\n\n    return new TargetGroupListenerAction(targetGroups, {\n      type: \"forward\",\n      forward: {\n        targetGroup: targetGroups.map((g) => ({\n          arn: g.targetGroupArn,\n        })),\n        stickiness: options.stickinessDuration\n          ? {\n              duration: options.stickinessDuration.toSeconds(),\n              enabled: true,\n            }\n          : undefined,\n      },\n    });\n  }\n\n  /**\n   * Forward to one or more Target Groups which are weighted differently\n   */\n  public static weightedForward(\n    targetGroups: NetworkWeightedTargetGroup[],\n    options: NetworkForwardOptions = {},\n  ): NetworkListenerAction {\n    if (targetGroups.length === 0) {\n      throw new Error(\n        \"Need at least one targetGroup in a NetworkListenerAction.weightedForward()\",\n      );\n    }\n\n    return new TargetGroupListenerAction(\n      targetGroups.map((g) => g.targetGroup),\n      {\n        type: \"forward\",\n        forward: {\n          targetGroup: targetGroups.map((g) => ({\n            arn: g.targetGroup.targetGroupArn,\n            weight: g.weight,\n          })),\n          stickiness: options.stickinessDuration\n            ? {\n                duration: options.stickinessDuration.toSeconds(),\n                enabled: true,\n              }\n            : undefined,\n        },\n      },\n    );\n  }\n\n  private _actionJson?: tfListenerRule.LbListenerRuleAction;\n\n  /**\n   * Create an instance of NetworkListenerAction\n   *\n   * The default class should be good enough for most cases and\n   * should be created by using one of the static factory functions,\n   * but allow overriding to make sure we allow flexibility for the future.\n   */\n  protected constructor(\n    private readonly defaultActionJson: tfListener.LbListenerDefaultAction,\n    protected readonly next?: NetworkListenerAction,\n  ) {}\n\n  /**\n   * Render the listener rule actions in this chain\n   */\n  public renderRuleActions(): tfListenerRule.LbListenerRuleAction[] {\n    const actionJson =\n      this._actionJson ??\n      (this.defaultActionJson as tfListenerRule.LbListenerRuleAction);\n    return this._renumber([\n      actionJson,\n      ...(this.next?.renderRuleActions() ?? []),\n    ]);\n  }\n\n  /**\n   * Render the listener default actions in this chain\n   */\n  public renderActions(): tfListener.LbListenerDefaultAction[] {\n    return this._renumber([\n      this.defaultActionJson,\n      ...(this.next?.renderActions() ?? []),\n    ]);\n  }\n\n  /**\n   * Called when the action is being used in a listener\n   */\n  public bind(scope: Construct, listener: INetworkListener) {\n    // Empty on purpose\n    Array.isArray(scope);\n    Array.isArray(listener);\n  }\n\n  private _renumber<\n    ActionProperty extends\n      | tfListener.LbListenerDefaultAction\n      | tfListenerRule.LbListenerRuleAction = tfListener.LbListenerDefaultAction,\n  >(actions: ActionProperty[]): ActionProperty[] {\n    if (actions.length < 2) {\n      return actions;\n    }\n\n    return actions.map((action, i) => ({ ...action, order: i + 1 }));\n  }\n\n  /**\n   * Renumber the \"order\" fields in the actions array.\n   *\n   * We don't number for 0 or 1 elements, but otherwise number them 1...#actions\n   * so ELB knows about the right order.\n   *\n   * Do this in `NetworkListenerAction` instead of in `Listener` so that we give\n   * users the opportunity to override by subclassing and overriding `renderActions`.\n   */\n  protected renumber(\n    actions: tfListener.LbListenerDefaultAction[],\n  ): tfListener.LbListenerDefaultAction[] {\n    return this._renumber(actions);\n  }\n}\n\n/**\n * Options for `NetworkListenerAction.forward()`\n */\nexport interface NetworkForwardOptions {\n  /**\n   * For how long clients should be directed to the same target group\n   *\n   * Range between 1 second and 7 days.\n   *\n   * @default - No stickiness\n   */\n  readonly stickinessDuration?: Duration;\n}\n\n/**\n * A Target Group and weight combination\n */\nexport interface NetworkWeightedTargetGroup {\n  /**\n   * The target group\n   */\n  readonly targetGroup: INetworkTargetGroup;\n\n  /**\n   * The target group's weight\n   *\n   * Range is [0..1000).\n   *\n   * @default 1\n   */\n  readonly weight?: number;\n}\n\n/**\n * Listener Action that calls \"registerListener\" on TargetGroups\n */\nclass TargetGroupListenerAction extends NetworkListenerAction {\n  constructor(\n    private readonly targetGroups: INetworkTargetGroup[],\n    defaultActionJson: tfListener.LbListenerDefaultAction,\n  ) {\n    super(defaultActionJson);\n  }\n\n  public bind(_scope: Construct, listener: INetworkListener) {\n    for (const tg of this.targetGroups) {\n      tg.registerListener(listener);\n    }\n  }\n}\n"]}

package/lib/aws/compute/nlb/network-listener-certificate.d.ts

@@ -0,0 +1,24 @@
+import { Construct } from "constructs";
+import { INetworkListener } from "./network-listener";
+import { IListenerCertificate } from "../lb-shared/listener-certificate";
+/**
+ * Properties for adding a set of certificates to a listener
+ */
+export interface NetworkListenerCertificateProps {
+    /**
+     * The listener to attach the rule to
+     */
+    readonly listener: INetworkListener;
+    /**
+     * Certificates to attach
+     *
+     * Duplicates are not allowed.
+     */
+    readonly certificates: IListenerCertificate[];
+}
+/**
+ * Add certificates to a listener
+ */
+export declare class NetworkListenerCertificate extends Construct {
+    constructor(scope: Construct, id: string, props: NetworkListenerCertificateProps);
+}

package/lib/aws/compute/nlb/network-listener-certificate.js

@@ -0,0 +1,25 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/nlb/network-listener-certificate.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkListenerCertificate = void 0;
+const provider_aws_1 = require("@cdktf/provider-aws");
+const constructs_1 = require("constructs");
+/**
+ * Add certificates to a listener
+ */
+class NetworkListenerCertificate extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const certificates = [
+            ...(props.certificates || []).map((c) => ({
+                certificateArn: c.certificateArn,
+            })),
+        ];
+        new provider_aws_1.lbListenerCertificate.LbListenerCertificate(this, "Resource", {
+            listenerArn: props.listener.listenerArn,
+            certificateArn: certificates[0].certificateArn,
+        });
+    }
+}
+exports.NetworkListenerCertificate = NetworkListenerCertificate;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/nlb/network-listener.d.ts

@@ -0,0 +1,248 @@
+import { Construct } from "constructs";
+import { NetworkListenerAction } from "./network-listener-action";
+import { INetworkLoadBalancer } from "./network-load-balancer";
+import { INetworkLoadBalancerTarget, INetworkTargetGroup, NetworkTargetGroup } from "./network-target-group";
+import { Duration } from "../../../duration";
+import { BaseListener, BaseListenerLookupOptions, IListener } from "../lb-shared/base-listener";
+import { HealthCheck } from "../lb-shared/base-target-group";
+import { AlpnPolicy, LbProtocol, SslPolicy } from "../lb-shared/enums";
+import { IListenerCertificate } from "../lb-shared/listener-certificate";
+/**
+ * Basic properties for a Network Listener
+ */
+export interface BaseNetworkListenerProps {
+    /**
+     * The port on which the listener listens for requests.
+     */
+    readonly port: number;
+    /**
+     * Default target groups to load balance to
+     *
+     * All target groups will be load balanced to with equal weight and without
+     * stickiness. For a more complex configuration than that, use
+     * either `defaultAction` or `addAction()`.
+     *
+     * Cannot be specified together with `defaultAction`.
+     *
+     * @default - None.
+     */
+    readonly defaultTargetGroups?: INetworkTargetGroup[];
+    /**
+     * Default action to take for requests to this listener
+     *
+     * This allows full control of the default Action of the load balancer,
+     * including weighted forwarding. See the `NetworkListenerAction` class for
+     * all options.
+     *
+     * Cannot be specified together with `defaultTargetGroups`.
+     *
+     * @default - None.
+     */
+    readonly defaultAction?: NetworkListenerAction;
+    /**
+     * Protocol for listener, expects TCP, TLS, UDP, or TCP_UDP.
+     *
+     * @default - TLS if certificates are provided. TCP otherwise.
+     */
+    readonly protocol?: LbProtocol;
+    /**
+     * Certificate list of ACM cert ARNs. You must provide exactly one certificate if the listener protocol is HTTPS or TLS.
+     *
+     * @default - No certificates.
+     */
+    readonly certificates?: IListenerCertificate[];
+    /**
+     * SSL Policy
+     *
+     * @default - Current predefined security policy.
+     */
+    readonly sslPolicy?: SslPolicy;
+    /**
+     * Application-Layer Protocol Negotiation (ALPN) is a TLS extension that is sent on the initial TLS handshake hello messages.
+     * ALPN enables the application layer to negotiate which protocols should be used over a secure connection, such as HTTP/1 and HTTP/2.
+     *
+     * Can only be specified together with Protocol TLS.
+     *
+     * @default - None
+     */
+    readonly alpnPolicy?: AlpnPolicy;
+    /**
+     * The load balancer TCP idle timeout.
+     *
+     * @default Duration.seconds(350)
+     */
+    readonly tcpIdleTimeout?: Duration;
+}
+/**
+ * Properties for adding a certificate to a listener
+ *
+ * This interface exists for backwards compatibility.
+ *
+ * @deprecated Use IListenerCertificate instead
+ */
+export interface INetworkListenerCertificateProps extends IListenerCertificate {
+}
+/**
+ * Properties for a Network Listener attached to a Load Balancer
+ */
+export interface NetworkListenerProps extends BaseNetworkListenerProps {
+    /**
+     * The load balancer to attach this listener to
+     */
+    readonly loadBalancer: INetworkLoadBalancer;
+}
+/**
+ * Options for looking up a network listener.
+ */
+export interface NetworkListenerLookupOptions extends BaseListenerLookupOptions {
+    /**
+     * Protocol of the listener port
+     * @default - listener is not filtered by protocol
+     */
+    readonly listenerProtocol?: LbProtocol;
+}
+/**
+ * Define a Network Listener
+ *
+ * @resource AWS::ElasticLoadBalancingV2::Listener
+ */
+export declare class NetworkListener extends BaseListener implements INetworkListener {
+    /**
+     * Import an existing listener
+     */
+    static fromNetworkListenerArn(scope: Construct, id: string, networkListenerArn: string): INetworkListener;
+    /**
+     * The load balancer this listener is attached to
+     */
+    readonly loadBalancer: INetworkLoadBalancer;
+    /**
+     * ARNs of certificates added to this listener
+     *
+     * The first certificate is used as the default certificate.
+     */
+    private readonly certificateArns;
+    /**
+     * the protocol of the listener
+     */
+    private readonly protocol;
+    constructor(scope: Construct, id: string, props: NetworkListenerProps);
+    /**
+     * Add one or more certificates to this listener.
+     *
+     * After the first certificate, this creates NetworkListenerCertificates
+     * resources since cloudformation requires the certificates array on the
+     * listener resource to have a length of 1.
+     */
+    addCertificates(id: string, certificates: IListenerCertificate[]): void;
+    /**
+     * Load balance incoming requests to the given target groups.
+     *
+     * All target groups will be load balanced to with equal weight and without
+     * stickiness. For a more complex configuration than that, use `addAction()`.
+     */
+    addTargetGroups(_id: string, ...targetGroups: INetworkTargetGroup[]): void;
+    /**
+     * Perform the given Action on incoming requests
+     *
+     * This allows full control of the default Action of the load balancer,
+     * including weighted forwarding. See the `NetworkListenerAction` class for
+     * all options.
+     */
+    addAction(_id: string, props: AddNetworkActionProps): void;
+    /**
+     * Load balance incoming requests to the given load balancing targets.
+     *
+     * This method implicitly creates a NetworkTargetGroup for the targets
+     * involved, and a 'forward' action to route traffic to the given TargetGroup.
+     *
+     * If you want more control over the precise setup, create the TargetGroup
+     * and use `addAction` yourself.
+     *
+     * It's possible to add conditions to the targets added in this way. At least
+     * one set of targets must be added without conditions.
+     *
+     * @returns The newly created target group
+     */
+    addTargets(id: string, props: AddNetworkTargetsProps): NetworkTargetGroup;
+    /**
+     * Wrapper for _setDefaultAction which does a type-safe bind
+     */
+    private setDefaultAction;
+}
+/**
+ * Properties to reference an existing listener
+ */
+export interface INetworkListener extends IListener {
+}
+/**
+ * Properties for adding a new action to a listener
+ */
+export interface AddNetworkActionProps {
+    /**
+     * Action to perform
+     */
+    readonly action: NetworkListenerAction;
+}
+/**
+ * Properties for adding new network targets to a listener
+ */
+export interface AddNetworkTargetsProps {
+    /**
+     * The port on which the target receives traffic.
+     *
+     * @default Determined from protocol if known
+     */
+    readonly port: number;
+    /**
+     * Protocol for target group, expects TCP, TLS, UDP, or TCP_UDP.
+     *
+     * @default - inherits the protocol of the listener
+     */
+    readonly protocol?: LbProtocol;
+    /**
+     * The targets to add to this target group.
+     *
+     * Can be `Instance`, `IPAddress`, or any self-registering load balancing
+     * target. If you use either `Instance` or `IPAddress` as targets, all
+     * target must be of the same type.
+     */
+    readonly targets?: INetworkLoadBalancerTarget[];
+    /**
+     * The name of the target group.
+     *
+     * This name must be unique per region per account, can have a maximum of
+     * 32 characters, must contain only alphanumeric characters or hyphens, and
+     * must not begin or end with a hyphen.
+     *
+     * @default Automatically generated
+     */
+    readonly targetGroupName?: string;
+    /**
+     * The amount of time for Elastic Load Balancing to wait before deregistering a target.
+     *
+     * The range is 0-3600 seconds.
+     *
+     * @default Duration.minutes(5)
+     */
+    readonly deregistrationDelay?: Duration;
+    /**
+     * Indicates whether Proxy Protocol version 2 is enabled.
+     *
+     * @default false
+     */
+    readonly proxyProtocolV2?: boolean;
+    /**
+     * Indicates whether client IP preservation is enabled.
+     *
+     * @default false if the target group type is IP address and the
+     * target group protocol is TCP or TLS. Otherwise, true.
+     */
+    readonly preserveClientIp?: boolean;
+    /**
+     * Health check configuration
+     *
+     * @default - The default value for each property in this configuration varies depending on the target.
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-targetgroup.html#aws-resource-elasticloadbalancingv2-targetgroup-properties
+     */
+    readonly healthCheck?: HealthCheck;
+}