aws-cdk-lib 2.171.1__py3-none-any.whl → 2.172.0__py3-none-any.whl

aws_cdk/aws_elasticloadbalancingv2/__init__.py

@@ -598,6 +598,47 @@ target_group = elbv2.ApplicationTargetGroup(self, "TargetGroup",
 )
 ```
 
+### IP Address Type for Target Groups
+
+You can set the IP address type for the target group by setting the `ipAddressType` property for both Application and Network target groups.
+
+If you set the `ipAddressType` property to `IPV6`, the VPC for the target group must have an associated IPv6 CIDR block.
+
+For more information, see IP address type for [Network Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-group-ip-address-type) and [Application Load Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-group-ip-address-type).
+
+```python
+# vpc: ec2.Vpc
+
+
+ipv4_application_target_group = elbv2.ApplicationTargetGroup(self, "IPv4ApplicationTargetGroup",
+    vpc=vpc,
+    port=80,
+    target_type=elbv2.TargetType.INSTANCE,
+    ip_address_type=elbv2.TargetGroupIpAddressType.IPV4
+)
+
+ipv6_application_target_group = elbv2.ApplicationTargetGroup(self, "Ipv6ApplicationTargetGroup",
+    vpc=vpc,
+    port=80,
+    target_type=elbv2.TargetType.INSTANCE,
+    ip_address_type=elbv2.TargetGroupIpAddressType.IPV6
+)
+
+ipv4_network_target_group = elbv2.NetworkTargetGroup(self, "IPv4NetworkTargetGroup",
+    vpc=vpc,
+    port=80,
+    target_type=elbv2.TargetType.INSTANCE,
+    ip_address_type=elbv2.TargetGroupIpAddressType.IPV4
+)
+
+ipv6_network_target_group = elbv2.NetworkTargetGroup(self, "Ipv6NetworkTargetGroup",
+    vpc=vpc,
+    port=80,
+    target_type=elbv2.TargetType.INSTANCE,
+    ip_address_type=elbv2.TargetGroupIpAddressType.IPV6
+)
+```
+
 ## Using Lambda Targets
 
 To use a Lambda Function as a target, use the integration class in the
@@ -3332,6 +3373,7 @@ class BaseNetworkListenerProps:
         "cross_zone_enabled": "crossZoneEnabled",
         "deregistration_delay": "deregistrationDelay",
         "health_check": "healthCheck",
+        "ip_address_type": "ipAddressType",
         "target_group_name": "targetGroupName",
         "target_type": "targetType",
         "vpc": "vpc",
@@ -3344,6 +3386,7 @@ class BaseTargetGroupProps:
         cross_zone_enabled: typing.Optional[builtins.bool] = None,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union["HealthCheck", typing.Dict[builtins.str, typing.Any]]] = None,
+        ip_address_type: typing.Optional["TargetGroupIpAddressType"] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional["TargetType"] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -3353,6 +3396,7 @@ class BaseTargetGroupProps:
         :param cross_zone_enabled: Indicates whether cross zone load balancing is enabled. Default: - use load balancer configuration
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
+        :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
         :param target_group_name: 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.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -3384,6 +3428,7 @@ class BaseTargetGroupProps:
                     timeout=cdk.Duration.minutes(30),
                     unhealthy_threshold_count=123
                 ),
+                ip_address_type=elbv2.TargetGroupIpAddressType.IPV4,
                 target_group_name="targetGroupName",
                 target_type=elbv2.TargetType.INSTANCE,
                 vpc=vpc
@@ -3396,6 +3441,7 @@ class BaseTargetGroupProps:
             check_type(argname="argument cross_zone_enabled", value=cross_zone_enabled, expected_type=type_hints["cross_zone_enabled"])
             check_type(argname="argument deregistration_delay", value=deregistration_delay, expected_type=type_hints["deregistration_delay"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
+            check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
             check_type(argname="argument target_group_name", value=target_group_name, expected_type=type_hints["target_group_name"])
             check_type(argname="argument target_type", value=target_type, expected_type=type_hints["target_type"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
@@ -3406,6 +3452,8 @@ class BaseTargetGroupProps:
             self._values["deregistration_delay"] = deregistration_delay
         if health_check is not None:
             self._values["health_check"] = health_check
+        if ip_address_type is not None:
+            self._values["ip_address_type"] = ip_address_type
         if target_group_name is not None:
             self._values["target_group_name"] = target_group_name
         if target_type is not None:
@@ -3446,6 +3494,15 @@ class BaseTargetGroupProps:
         result = self._values.get("health_check")
         return typing.cast(typing.Optional["HealthCheck"], result)
 
+    @builtins.property
+    def ip_address_type(self) -> typing.Optional["TargetGroupIpAddressType"]:
+        '''The type of IP addresses of the targets registered with the target group.
+
+        :default: undefined - ELB defaults to IPv4
+        '''
+        result = self._values.get("ip_address_type")
+        return typing.cast(typing.Optional["TargetGroupIpAddressType"], result)
+
     @builtins.property
     def target_group_name(self) -> typing.Optional[builtins.str]:
         '''The name of the target group.
@@ -8174,6 +8231,9 @@ class CfnLoadBalancer(
                 key="key",
                 value="value"
             )],
+            minimum_load_balancer_capacity=elbv2.CfnLoadBalancer.MinimumLoadBalancerCapacityProperty(
+                capacity_units=123
+            ),
             name="name",
             scheme="scheme",
             security_groups=["securityGroups"],
@@ -8204,6 +8264,7 @@ class CfnLoadBalancer(
         enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
         ip_address_type: typing.Optional[builtins.str] = None,
         load_balancer_attributes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLoadBalancer.LoadBalancerAttributeProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        minimum_load_balancer_capacity: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnLoadBalancer.MinimumLoadBalancerCapacityProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         name: typing.Optional[builtins.str] = None,
         scheme: typing.Optional[builtins.str] = None,
         security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -8219,6 +8280,7 @@ class CfnLoadBalancer(
         :param enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink .
         :param ip_address_type: The IP address type. Internal load balancers must use ``ipv4`` . [Application Load Balancers] The possible values are ``ipv4`` (IPv4 addresses), ``dualstack`` (IPv4 and IPv6 addresses), and ``dualstack-without-public-ipv4`` (public IPv6 addresses and private IPv4 and IPv6 addresses). Application Load Balancer authentication supports IPv4 addresses only when connecting to an Identity Provider (IdP) or Amazon Cognito endpoint. Without a public IPv4 address the load balancer can't complete the authentication process, resulting in HTTP 500 errors. [Network Load Balancers and Gateway Load Balancers] The possible values are ``ipv4`` (IPv4 addresses) and ``dualstack`` (IPv4 and IPv6 addresses).
         :param load_balancer_attributes: The load balancer attributes.
+        :param minimum_load_balancer_capacity: 
         :param name: The name of the load balancer. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, must not begin or end with a hyphen, and must not begin with "internal-". If you don't specify a name, AWS CloudFormation generates a unique physical ID for the load balancer. If you specify a name, you cannot perform updates that require replacement of this resource, but you can perform other updates. To replace the resource, specify a new name.
         :param scheme: The nodes of an Internet-facing load balancer have public IP addresses. The DNS name of an Internet-facing load balancer is publicly resolvable to the public IP addresses of the nodes. Therefore, Internet-facing load balancers can route requests from clients over the internet. The nodes of an internal load balancer have only private IP addresses. The DNS name of an internal load balancer is publicly resolvable to the private IP addresses of the nodes. Therefore, internal load balancers can route requests only from clients with access to the VPC for the load balancer. The default is an Internet-facing load balancer. You can't specify a scheme for a Gateway Load Balancer.
         :param security_groups: [Application Load Balancers and Network Load Balancers] The IDs of the security groups for the load balancer.
@@ -8236,6 +8298,7 @@ class CfnLoadBalancer(
             enforce_security_group_inbound_rules_on_private_link_traffic=enforce_security_group_inbound_rules_on_private_link_traffic,
             ip_address_type=ip_address_type,
             load_balancer_attributes=load_balancer_attributes,
+            minimum_load_balancer_capacity=minimum_load_balancer_capacity,
             name=name,
             scheme=scheme,
             security_groups=security_groups,
@@ -8418,6 +8481,23 @@ class CfnLoadBalancer(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "loadBalancerAttributes", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="minimumLoadBalancerCapacity")
+    def minimum_load_balancer_capacity(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLoadBalancer.MinimumLoadBalancerCapacityProperty"]]:
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLoadBalancer.MinimumLoadBalancerCapacityProperty"]], jsii.get(self, "minimumLoadBalancerCapacity"))
+
+    @minimum_load_balancer_capacity.setter
+    def minimum_load_balancer_capacity(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnLoadBalancer.MinimumLoadBalancerCapacityProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__102164e78a5cf61e67908e476a27971c19e5604c38d90ddca6b4b346581d0209)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "minimumLoadBalancerCapacity", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="name")
     def name(self) -> typing.Optional[builtins.str]:
@@ -8623,6 +8703,56 @@ class CfnLoadBalancer(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.CfnLoadBalancer.MinimumLoadBalancerCapacityProperty",
+        jsii_struct_bases=[],
+        name_mapping={"capacity_units": "capacityUnits"},
+    )
+    class MinimumLoadBalancerCapacityProperty:
+        def __init__(self, *, capacity_units: jsii.Number) -> None:
+            '''
+            :param capacity_units: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-loadbalancer-minimumloadbalancercapacity.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_elasticloadbalancingv2 as elbv2
+                
+                minimum_load_balancer_capacity_property = elbv2.CfnLoadBalancer.MinimumLoadBalancerCapacityProperty(
+                    capacity_units=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__bd0d2d4a891c02fabab09ae876b5f738a440bf3402f1db5dc28e3cdd47b733bc)
+                check_type(argname="argument capacity_units", value=capacity_units, expected_type=type_hints["capacity_units"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "capacity_units": capacity_units,
+            }
+
+        @builtins.property
+        def capacity_units(self) -> jsii.Number:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-loadbalancer-minimumloadbalancercapacity.html#cfn-elasticloadbalancingv2-loadbalancer-minimumloadbalancercapacity-capacityunits
+            '''
+            result = self._values.get("capacity_units")
+            assert result is not None, "Required property 'capacity_units' is missing"
+            return typing.cast(jsii.Number, result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "MinimumLoadBalancerCapacityProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.CfnLoadBalancer.SubnetMappingProperty",
         jsii_struct_bases=[],
@@ -8758,6 +8888,7 @@ class CfnLoadBalancer(
         "enforce_security_group_inbound_rules_on_private_link_traffic": "enforceSecurityGroupInboundRulesOnPrivateLinkTraffic",
         "ip_address_type": "ipAddressType",
         "load_balancer_attributes": "loadBalancerAttributes",
+        "minimum_load_balancer_capacity": "minimumLoadBalancerCapacity",
         "name": "name",
         "scheme": "scheme",
         "security_groups": "securityGroups",
@@ -8775,6 +8906,7 @@ class CfnLoadBalancerProps:
         enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
         ip_address_type: typing.Optional[builtins.str] = None,
         load_balancer_attributes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLoadBalancer.LoadBalancerAttributeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        minimum_load_balancer_capacity: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLoadBalancer.MinimumLoadBalancerCapacityProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         name: typing.Optional[builtins.str] = None,
         scheme: typing.Optional[builtins.str] = None,
         security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -8789,6 +8921,7 @@ class CfnLoadBalancerProps:
         :param enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through AWS PrivateLink .
         :param ip_address_type: The IP address type. Internal load balancers must use ``ipv4`` . [Application Load Balancers] The possible values are ``ipv4`` (IPv4 addresses), ``dualstack`` (IPv4 and IPv6 addresses), and ``dualstack-without-public-ipv4`` (public IPv6 addresses and private IPv4 and IPv6 addresses). Application Load Balancer authentication supports IPv4 addresses only when connecting to an Identity Provider (IdP) or Amazon Cognito endpoint. Without a public IPv4 address the load balancer can't complete the authentication process, resulting in HTTP 500 errors. [Network Load Balancers and Gateway Load Balancers] The possible values are ``ipv4`` (IPv4 addresses) and ``dualstack`` (IPv4 and IPv6 addresses).
         :param load_balancer_attributes: The load balancer attributes.
+        :param minimum_load_balancer_capacity: 
         :param name: The name of the load balancer. This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens, must not begin or end with a hyphen, and must not begin with "internal-". If you don't specify a name, AWS CloudFormation generates a unique physical ID for the load balancer. If you specify a name, you cannot perform updates that require replacement of this resource, but you can perform other updates. To replace the resource, specify a new name.
         :param scheme: The nodes of an Internet-facing load balancer have public IP addresses. The DNS name of an Internet-facing load balancer is publicly resolvable to the public IP addresses of the nodes. Therefore, Internet-facing load balancers can route requests from clients over the internet. The nodes of an internal load balancer have only private IP addresses. The DNS name of an internal load balancer is publicly resolvable to the private IP addresses of the nodes. Therefore, internal load balancers can route requests only from clients with access to the VPC for the load balancer. The default is an Internet-facing load balancer. You can't specify a scheme for a Gateway Load Balancer.
         :param security_groups: [Application Load Balancers and Network Load Balancers] The IDs of the security groups for the load balancer.
@@ -8814,6 +8947,9 @@ class CfnLoadBalancerProps:
                     key="key",
                     value="value"
                 )],
+                minimum_load_balancer_capacity=elbv2.CfnLoadBalancer.MinimumLoadBalancerCapacityProperty(
+                    capacity_units=123
+                ),
                 name="name",
                 scheme="scheme",
                 security_groups=["securityGroups"],
@@ -8840,6 +8976,7 @@ class CfnLoadBalancerProps:
             check_type(argname="argument enforce_security_group_inbound_rules_on_private_link_traffic", value=enforce_security_group_inbound_rules_on_private_link_traffic, expected_type=type_hints["enforce_security_group_inbound_rules_on_private_link_traffic"])
             check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
             check_type(argname="argument load_balancer_attributes", value=load_balancer_attributes, expected_type=type_hints["load_balancer_attributes"])
+            check_type(argname="argument minimum_load_balancer_capacity", value=minimum_load_balancer_capacity, expected_type=type_hints["minimum_load_balancer_capacity"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             check_type(argname="argument scheme", value=scheme, expected_type=type_hints["scheme"])
             check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
@@ -8856,6 +8993,8 @@ class CfnLoadBalancerProps:
             self._values["ip_address_type"] = ip_address_type
         if load_balancer_attributes is not None:
             self._values["load_balancer_attributes"] = load_balancer_attributes
+        if minimum_load_balancer_capacity is not None:
+            self._values["minimum_load_balancer_capacity"] = minimum_load_balancer_capacity
         if name is not None:
             self._values["name"] = name
         if scheme is not None:
@@ -8919,6 +9058,16 @@ class CfnLoadBalancerProps:
         result = self._values.get("load_balancer_attributes")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnLoadBalancer.LoadBalancerAttributeProperty]]]], result)
 
+    @builtins.property
+    def minimum_load_balancer_capacity(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnLoadBalancer.MinimumLoadBalancerCapacityProperty]]:
+        '''
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticloadbalancingv2-loadbalancer.html#cfn-elasticloadbalancingv2-loadbalancer-minimumloadbalancercapacity
+        '''
+        result = self._values.get("minimum_load_balancer_capacity")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnLoadBalancer.MinimumLoadBalancerCapacityProperty]], result)
+
     @builtins.property
     def name(self) -> typing.Optional[builtins.str]:
         '''The name of the load balancer.
@@ -11284,14 +11433,14 @@ class HealthCheck:
         '''Properties for configuring a health check.
 
         :param enabled: Indicates whether health checks are enabled. If the target type is lambda, health checks are disabled by default but can be enabled. If the target type is instance or ip, health checks are always enabled and cannot be disabled. Default: - Determined automatically.
-        :param healthy_grpc_codes: GRPC code to use when checking for a successful response from a target. You can specify values between 0 and 99. You can specify multiple values (for example, "0,1") or a range of values (for example, "0-5"). Default: - 12
+        :param healthy_grpc_codes: GRPC code to use when checking for a successful response from a target. You can specify values between 0 and 99. You can specify multiple values (for example, "0,1") or a range of values (for example, "0-5"). Default: 12
         :param healthy_http_codes: HTTP code to use when checking for a successful response from a target. For Application Load Balancers, you can specify values between 200 and 499, and the default value is 200. You can specify multiple values (for example, "200,202") or a range of values (for example, "200-299").
-        :param healthy_threshold_count: The number of consecutive health checks successes required before considering an unhealthy target healthy. For Application Load Balancers, the default is 5. For Network Load Balancers, the default is 3. Default: 5 for ALBs, 3 for NLBs
-        :param interval: The approximate number of seconds between health checks for an individual target. Must be 5 to 300 seconds Default: 10 seconds if protocol is ``GENEVE``, 35 seconds if target type is ``lambda``, else 30 seconds
+        :param healthy_threshold_count: The number of consecutive health checks successes required before considering an unhealthy target healthy. For Application Load Balancers, the default is 5. For Network Load Balancers, the default is 3. Default: - 5 for ALBs, 3 for NLBs
+        :param interval: The approximate number of seconds between health checks for an individual target. Must be 5 to 300 seconds Default: - 10 seconds if protocol is ``GENEVE``, 35 seconds if target type is ``lambda``, else 30 seconds
         :param path: The ping path destination where Elastic Load Balancing sends health check requests. Default: /
         :param port: The port that the load balancer uses when performing health checks on the targets. Default: 'traffic-port'
-        :param protocol: The protocol the load balancer uses when performing health checks on targets. The TCP protocol is supported for health checks only if the protocol of the target group is TCP, TLS, UDP, or TCP_UDP. The TLS, UDP, and TCP_UDP protocols are not supported for health checks. Default: HTTP for ALBs, TCP for NLBs
-        :param timeout: The amount of time, in seconds, during which no response from a target means a failed health check. Must be 2 to 120 seconds. 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
+        :param protocol: The protocol the load balancer uses when performing health checks on targets. The TCP protocol is supported for health checks only if the protocol of the target group is TCP, TLS, UDP, or TCP_UDP. The TLS, UDP, and TCP_UDP protocols are not supported for health checks. Default: - HTTP for ALBs, TCP for NLBs
+        :param timeout: The amount of time, in seconds, during which no response from a target means a failed health check. Must be 2 to 120 seconds. 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
         :param unhealthy_threshold_count: The number of consecutive health check failures required before considering a target unhealthy. For Application Load Balancers, the default is 2. For Network Load Balancers, this value must be the same as the healthy threshold count. Default: 2
 
         :exampleMetadata: infused
@@ -11369,7 +11518,7 @@ class HealthCheck:
         You can specify values between 0 and 99. You can specify multiple values
         (for example, "0,1") or a range of values (for example, "0-5").
 
-        :default: - 12
+        :default: 12
         '''
         result = self._values.get("healthy_grpc_codes")
         return typing.cast(typing.Optional[builtins.str], result)
@@ -11391,7 +11540,7 @@ class HealthCheck:
 
         For Application Load Balancers, the default is 5. For Network Load Balancers, the default is 3.
 
-        :default: 5 for ALBs, 3 for NLBs
+        :default: - 5 for ALBs, 3 for NLBs
         '''
         result = self._values.get("healthy_threshold_count")
         return typing.cast(typing.Optional[jsii.Number], result)
@@ -11402,7 +11551,7 @@ class HealthCheck:
 
         Must be 5 to 300 seconds
 
-        :default: 10 seconds if protocol is ``GENEVE``, 35 seconds if target type is ``lambda``, else 30 seconds
+        :default: - 10 seconds if protocol is ``GENEVE``, 35 seconds if target type is ``lambda``, else 30 seconds
         '''
         result = self._values.get("interval")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
@@ -11432,7 +11581,7 @@ class HealthCheck:
         The TCP protocol is supported for health checks only if the protocol of the target group is TCP, TLS, UDP, or TCP_UDP.
         The TLS, UDP, and TCP_UDP protocols are not supported for health checks.
 
-        :default: HTTP for ALBs, TCP for NLBs
+        :default: - HTTP for ALBs, TCP for NLBs
         '''
         result = self._values.get("protocol")
         return typing.cast(typing.Optional["Protocol"], result)
@@ -11443,7 +11592,7 @@ class HealthCheck:
 
         Must be 2 to 120 seconds.
 
-        :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
+        :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
         '''
         result = self._values.get("timeout")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
@@ -17617,6 +17766,7 @@ class NetworkLoadBalancerProps(BaseLoadBalancerProps):
         "cross_zone_enabled": "crossZoneEnabled",
         "deregistration_delay": "deregistrationDelay",
         "health_check": "healthCheck",
+        "ip_address_type": "ipAddressType",
         "target_group_name": "targetGroupName",
         "target_type": "targetType",
         "vpc": "vpc",
@@ -17635,6 +17785,7 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         cross_zone_enabled: typing.Optional[builtins.bool] = None,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+        ip_address_type: typing.Optional["TargetGroupIpAddressType"] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional["TargetType"] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -17650,6 +17801,7 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         :param cross_zone_enabled: Indicates whether cross zone load balancing is enabled. Default: - use load balancer configuration
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
+        :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
         :param target_group_name: 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.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -17660,45 +17812,39 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         :param proxy_protocol_v2: Indicates whether Proxy Protocol version 2 is enabled. Default: false
         :param targets: 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. Default: - No targets.
 
-        :exampleMetadata: fixture=_generated
+        :exampleMetadata: infused
 
         Example::
 
-            # The code below shows an example of how to instantiate this type.
-            # The values are placeholders you should change.
-            import aws_cdk as cdk
-            from aws_cdk import aws_ec2 as ec2
-            from aws_cdk import aws_elasticloadbalancingv2 as elbv2
-            
-            # network_load_balancer_target: elbv2.INetworkLoadBalancerTarget
             # vpc: ec2.Vpc
             
-            network_target_group_props = elbv2.NetworkTargetGroupProps(
-                port=123,
             
-                # the properties below are optional
-                connection_termination=False,
-                cross_zone_enabled=False,
-                deregistration_delay=cdk.Duration.minutes(30),
-                health_check=elbv2.HealthCheck(
-                    enabled=False,
-                    healthy_grpc_codes="healthyGrpcCodes",
-                    healthy_http_codes="healthyHttpCodes",
-                    healthy_threshold_count=123,
-                    interval=cdk.Duration.minutes(30),
-                    path="path",
-                    port="port",
-                    protocol=elbv2.Protocol.HTTP,
-                    timeout=cdk.Duration.minutes(30),
-                    unhealthy_threshold_count=123
-                ),
-                preserve_client_ip=False,
-                protocol=elbv2.Protocol.HTTP,
-                proxy_protocol_v2=False,
-                target_group_name="targetGroupName",
-                targets=[network_load_balancer_target],
+            ipv4_application_target_group = elbv2.ApplicationTargetGroup(self, "IPv4ApplicationTargetGroup",
+                vpc=vpc,
+                port=80,
                 target_type=elbv2.TargetType.INSTANCE,
-                vpc=vpc
+                ip_address_type=elbv2.TargetGroupIpAddressType.IPV4
+            )
+            
+            ipv6_application_target_group = elbv2.ApplicationTargetGroup(self, "Ipv6ApplicationTargetGroup",
+                vpc=vpc,
+                port=80,
+                target_type=elbv2.TargetType.INSTANCE,
+                ip_address_type=elbv2.TargetGroupIpAddressType.IPV6
+            )
+            
+            ipv4_network_target_group = elbv2.NetworkTargetGroup(self, "IPv4NetworkTargetGroup",
+                vpc=vpc,
+                port=80,
+                target_type=elbv2.TargetType.INSTANCE,
+                ip_address_type=elbv2.TargetGroupIpAddressType.IPV4
+            )
+            
+            ipv6_network_target_group = elbv2.NetworkTargetGroup(self, "Ipv6NetworkTargetGroup",
+                vpc=vpc,
+                port=80,
+                target_type=elbv2.TargetType.INSTANCE,
+                ip_address_type=elbv2.TargetGroupIpAddressType.IPV6
             )
         '''
         if isinstance(health_check, dict):
@@ -17708,6 +17854,7 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
             check_type(argname="argument cross_zone_enabled", value=cross_zone_enabled, expected_type=type_hints["cross_zone_enabled"])
             check_type(argname="argument deregistration_delay", value=deregistration_delay, expected_type=type_hints["deregistration_delay"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
+            check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
             check_type(argname="argument target_group_name", value=target_group_name, expected_type=type_hints["target_group_name"])
             check_type(argname="argument target_type", value=target_type, expected_type=type_hints["target_type"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
@@ -17726,6 +17873,8 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
             self._values["deregistration_delay"] = deregistration_delay
         if health_check is not None:
             self._values["health_check"] = health_check
+        if ip_address_type is not None:
+            self._values["ip_address_type"] = ip_address_type
         if target_group_name is not None:
             self._values["target_group_name"] = target_group_name
         if target_type is not None:
@@ -17776,6 +17925,15 @@ class NetworkTargetGroupProps(BaseTargetGroupProps):
         result = self._values.get("health_check")
         return typing.cast(typing.Optional[HealthCheck], result)
 
+    @builtins.property
+    def ip_address_type(self) -> typing.Optional["TargetGroupIpAddressType"]:
+        '''The type of IP addresses of the targets registered with the target group.
+
+        :default: undefined - ELB defaults to IPv4
+        '''
+        result = self._values.get("ip_address_type")
+        return typing.cast(typing.Optional["TargetGroupIpAddressType"], result)
+
     @builtins.property
     def target_group_name(self) -> typing.Optional[builtins.str]:
         '''The name of the target group.
@@ -18703,14 +18861,14 @@ class TargetGroupBase(
         '''Set/replace the target group's health check.
 
         :param enabled: Indicates whether health checks are enabled. If the target type is lambda, health checks are disabled by default but can be enabled. If the target type is instance or ip, health checks are always enabled and cannot be disabled. Default: - Determined automatically.
-        :param healthy_grpc_codes: GRPC code to use when checking for a successful response from a target. You can specify values between 0 and 99. You can specify multiple values (for example, "0,1") or a range of values (for example, "0-5"). Default: - 12
+        :param healthy_grpc_codes: GRPC code to use when checking for a successful response from a target. You can specify values between 0 and 99. You can specify multiple values (for example, "0,1") or a range of values (for example, "0-5"). Default: 12
         :param healthy_http_codes: HTTP code to use when checking for a successful response from a target. For Application Load Balancers, you can specify values between 200 and 499, and the default value is 200. You can specify multiple values (for example, "200,202") or a range of values (for example, "200-299").
-        :param healthy_threshold_count: The number of consecutive health checks successes required before considering an unhealthy target healthy. For Application Load Balancers, the default is 5. For Network Load Balancers, the default is 3. Default: 5 for ALBs, 3 for NLBs
-        :param interval: The approximate number of seconds between health checks for an individual target. Must be 5 to 300 seconds Default: 10 seconds if protocol is ``GENEVE``, 35 seconds if target type is ``lambda``, else 30 seconds
+        :param healthy_threshold_count: The number of consecutive health checks successes required before considering an unhealthy target healthy. For Application Load Balancers, the default is 5. For Network Load Balancers, the default is 3. Default: - 5 for ALBs, 3 for NLBs
+        :param interval: The approximate number of seconds between health checks for an individual target. Must be 5 to 300 seconds Default: - 10 seconds if protocol is ``GENEVE``, 35 seconds if target type is ``lambda``, else 30 seconds
         :param path: The ping path destination where Elastic Load Balancing sends health check requests. Default: /
         :param port: The port that the load balancer uses when performing health checks on the targets. Default: 'traffic-port'
-        :param protocol: The protocol the load balancer uses when performing health checks on targets. The TCP protocol is supported for health checks only if the protocol of the target group is TCP, TLS, UDP, or TCP_UDP. The TLS, UDP, and TCP_UDP protocols are not supported for health checks. Default: HTTP for ALBs, TCP for NLBs
-        :param timeout: The amount of time, in seconds, during which no response from a target means a failed health check. Must be 2 to 120 seconds. 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
+        :param protocol: The protocol the load balancer uses when performing health checks on targets. The TCP protocol is supported for health checks only if the protocol of the target group is TCP, TLS, UDP, or TCP_UDP. The TLS, UDP, and TCP_UDP protocols are not supported for health checks. Default: - HTTP for ALBs, TCP for NLBs
+        :param timeout: The amount of time, in seconds, during which no response from a target means a failed health check. Must be 2 to 120 seconds. 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
         :param unhealthy_threshold_count: The number of consecutive health check failures required before considering a target unhealthy. For Application Load Balancers, the default is 2. For Network Load Balancers, this value must be the same as the healthy threshold count. Default: 2
         '''
         health_check = HealthCheck(
@@ -18862,6 +19020,52 @@ class _TargetGroupBaseProxy(TargetGroupBase):
 typing.cast(typing.Any, TargetGroupBase).__jsii_proxy_class__ = lambda : _TargetGroupBaseProxy
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.TargetGroupIpAddressType")
+class TargetGroupIpAddressType(enum.Enum):
+    '''The IP address type of targets registered with a target group.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # vpc: ec2.Vpc
+        
+        
+        ipv4_application_target_group = elbv2.ApplicationTargetGroup(self, "IPv4ApplicationTargetGroup",
+            vpc=vpc,
+            port=80,
+            target_type=elbv2.TargetType.INSTANCE,
+            ip_address_type=elbv2.TargetGroupIpAddressType.IPV4
+        )
+        
+        ipv6_application_target_group = elbv2.ApplicationTargetGroup(self, "Ipv6ApplicationTargetGroup",
+            vpc=vpc,
+            port=80,
+            target_type=elbv2.TargetType.INSTANCE,
+            ip_address_type=elbv2.TargetGroupIpAddressType.IPV6
+        )
+        
+        ipv4_network_target_group = elbv2.NetworkTargetGroup(self, "IPv4NetworkTargetGroup",
+            vpc=vpc,
+            port=80,
+            target_type=elbv2.TargetType.INSTANCE,
+            ip_address_type=elbv2.TargetGroupIpAddressType.IPV4
+        )
+        
+        ipv6_network_target_group = elbv2.NetworkTargetGroup(self, "Ipv6NetworkTargetGroup",
+            vpc=vpc,
+            port=80,
+            target_type=elbv2.TargetType.INSTANCE,
+            ip_address_type=elbv2.TargetGroupIpAddressType.IPV6
+        )
+    '''
+
+    IPV4 = "IPV4"
+    '''IPv4 addresses.'''
+    IPV6 = "IPV6"
+    '''IPv6 addresses.'''
+
+
 @jsii.enum(
     jsii_type="aws-cdk-lib.aws_elasticloadbalancingv2.TargetGroupLoadBalancingAlgorithmType"
 )
@@ -18901,11 +19105,15 @@ class TargetType(enum.Enum):
         # vpc: ec2.Vpc
         
         
-        # Target group with slow start mode enabled
         tg = elbv2.ApplicationTargetGroup(self, "TG",
-            target_type=elbv2.TargetType.INSTANCE,
-            slow_start=Duration.seconds(60),
-            port=80,
+            target_type=elbv2.TargetType.IP,
+            port=50051,
+            protocol=elbv2.ApplicationProtocol.HTTP,
+            protocol_version=elbv2.ApplicationProtocolVersion.GRPC,
+            health_check=elbv2.HealthCheck(
+                enabled=True,
+                healthy_grpc_codes="0-99"
+            ),
             vpc=vpc
         )
     '''
@@ -20889,6 +21097,7 @@ class ApplicationLoadBalancerProps(BaseLoadBalancerProps):
         "cross_zone_enabled": "crossZoneEnabled",
         "deregistration_delay": "deregistrationDelay",
         "health_check": "healthCheck",
+        "ip_address_type": "ipAddressType",
         "target_group_name": "targetGroupName",
         "target_type": "targetType",
         "vpc": "vpc",
@@ -20910,6 +21119,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         cross_zone_enabled: typing.Optional[builtins.bool] = None,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+        ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional[TargetType] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -20928,6 +21138,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         :param cross_zone_enabled: Indicates whether cross zone load balancing is enabled. Default: - use load balancer configuration
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
+        :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
         :param target_group_name: 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.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -20948,11 +21159,15 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
             # vpc: ec2.Vpc
             
             
-            # Target group with slow start mode enabled
             tg = elbv2.ApplicationTargetGroup(self, "TG",
-                target_type=elbv2.TargetType.INSTANCE,
-                slow_start=Duration.seconds(60),
-                port=80,
+                target_type=elbv2.TargetType.IP,
+                port=50051,
+                protocol=elbv2.ApplicationProtocol.HTTP,
+                protocol_version=elbv2.ApplicationProtocolVersion.GRPC,
+                health_check=elbv2.HealthCheck(
+                    enabled=True,
+                    healthy_grpc_codes="0-99"
+                ),
                 vpc=vpc
             )
         '''
@@ -20963,6 +21178,7 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
             check_type(argname="argument cross_zone_enabled", value=cross_zone_enabled, expected_type=type_hints["cross_zone_enabled"])
             check_type(argname="argument deregistration_delay", value=deregistration_delay, expected_type=type_hints["deregistration_delay"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
+            check_type(argname="argument ip_address_type", value=ip_address_type, expected_type=type_hints["ip_address_type"])
             check_type(argname="argument target_group_name", value=target_group_name, expected_type=type_hints["target_group_name"])
             check_type(argname="argument target_type", value=target_type, expected_type=type_hints["target_type"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
@@ -20982,6 +21198,8 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
             self._values["deregistration_delay"] = deregistration_delay
         if health_check is not None:
             self._values["health_check"] = health_check
+        if ip_address_type is not None:
+            self._values["ip_address_type"] = ip_address_type
         if target_group_name is not None:
             self._values["target_group_name"] = target_group_name
         if target_type is not None:
@@ -21040,6 +21258,15 @@ class ApplicationTargetGroupProps(BaseTargetGroupProps):
         result = self._values.get("health_check")
         return typing.cast(typing.Optional[HealthCheck], result)
 
+    @builtins.property
+    def ip_address_type(self) -> typing.Optional[TargetGroupIpAddressType]:
+        '''The type of IP addresses of the targets registered with the target group.
+
+        :default: undefined - ELB defaults to IPv4
+        '''
+        result = self._values.get("ip_address_type")
+        return typing.cast(typing.Optional[TargetGroupIpAddressType], result)
+
     @builtins.property
     def target_group_name(self) -> typing.Optional[builtins.str]:
         '''The name of the target group.
@@ -22271,6 +22498,7 @@ class NetworkTargetGroup(
         cross_zone_enabled: typing.Optional[builtins.bool] = None,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+        ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional[TargetType] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -22287,6 +22515,7 @@ class NetworkTargetGroup(
         :param cross_zone_enabled: Indicates whether cross zone load balancing is enabled. Default: - use load balancer configuration
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
+        :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
         :param target_group_name: 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.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -22305,6 +22534,7 @@ class NetworkTargetGroup(
             cross_zone_enabled=cross_zone_enabled,
             deregistration_delay=deregistration_delay,
             health_check=health_check,
+            ip_address_type=ip_address_type,
             target_group_name=target_group_name,
             target_type=target_type,
             vpc=vpc,
@@ -24230,6 +24460,7 @@ class ApplicationTargetGroup(
         cross_zone_enabled: typing.Optional[builtins.bool] = None,
         deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
         health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+        ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
         target_group_name: typing.Optional[builtins.str] = None,
         target_type: typing.Optional[TargetType] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -24249,6 +24480,7 @@ class ApplicationTargetGroup(
         :param cross_zone_enabled: Indicates whether cross zone load balancing is enabled. Default: - use load balancer configuration
         :param deregistration_delay: The amount of time for Elastic Load Balancing to wait before deregistering a target. The range is 0-3600 seconds. Default: 300
         :param health_check: Health check configuration. Default: - The default value for each property in this configuration varies depending on the target.
+        :param ip_address_type: The type of IP addresses of the targets registered with the target group. Default: undefined - ELB defaults to IPv4
         :param target_group_name: 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.
         :param target_type: The type of targets registered to this TargetGroup, either IP or Instance. All targets registered into the group must be of this type. If you register targets to the TargetGroup in the CDK app, the TargetType is determined automatically. Default: - Determined automatically.
         :param vpc: The virtual private cloud (VPC). only if ``TargetType`` is ``Ip`` or ``InstanceId`` Default: - undefined
@@ -24270,6 +24502,7 @@ class ApplicationTargetGroup(
             cross_zone_enabled=cross_zone_enabled,
             deregistration_delay=deregistration_delay,
             health_check=health_check,
+            ip_address_type=ip_address_type,
             target_group_name=target_group_name,
             target_type=target_type,
             vpc=vpc,
@@ -24942,6 +25175,7 @@ __all__ = [
     "SslPolicy",
     "TargetGroupAttributes",
     "TargetGroupBase",
+    "TargetGroupIpAddressType",
     "TargetGroupLoadBalancingAlgorithmType",
     "TargetType",
     "TrustStore",
@@ -25180,6 +25414,7 @@ def _typecheckingstub__b5e7f5d87f70cb030d7ac44f4637a5d73814a6c8b1c1bff9adf19ede8
     cross_zone_enabled: typing.Optional[builtins.bool] = None,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+    ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -25671,6 +25906,7 @@ def _typecheckingstub__907e1e3e88136a6a7bdcdac293563447ed893c77b9f7b1e7154fb1749
     enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
     ip_address_type: typing.Optional[builtins.str] = None,
     load_balancer_attributes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLoadBalancer.LoadBalancerAttributeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    minimum_load_balancer_capacity: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLoadBalancer.MinimumLoadBalancerCapacityProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
     scheme: typing.Optional[builtins.str] = None,
     security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -25718,6 +25954,12 @@ def _typecheckingstub__8b18943454864026c64dd9c2bc7fdaf60ac5114bf771f7304a82e9bdf
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__102164e78a5cf61e67908e476a27971c19e5604c38d90ddca6b4b346581d0209(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnLoadBalancer.MinimumLoadBalancerCapacityProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__153ca4a32dcbf43c1076bdc45b59a5463ab49120f83591bcbf13f84ce3fffa0e(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -25768,6 +26010,13 @@ def _typecheckingstub__981f45ac63ed8e62237b89c4cadf7d8f1c042e4534c384c148e58bad2
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__bd0d2d4a891c02fabab09ae876b5f738a440bf3402f1db5dc28e3cdd47b733bc(
+    *,
+    capacity_units: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__5362b7e1b57cc75205d80d2c4a4798301f16a110c6add8b836265fc95f89ec11(
     *,
     subnet_id: builtins.str,
@@ -25785,6 +26034,7 @@ def _typecheckingstub__6b1eb30cea756dc45f625ec82ab8cba6ea31d24595a925a4aabceb7e6
     enforce_security_group_inbound_rules_on_private_link_traffic: typing.Optional[builtins.str] = None,
     ip_address_type: typing.Optional[builtins.str] = None,
     load_balancer_attributes: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLoadBalancer.LoadBalancerAttributeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    minimum_load_balancer_capacity: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnLoadBalancer.MinimumLoadBalancerCapacityProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
     scheme: typing.Optional[builtins.str] = None,
     security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -26597,6 +26847,7 @@ def _typecheckingstub__5f1086cffe813b24d7b8ff7c124bffc37ca7e22afda9f6af7ad869d92
     cross_zone_enabled: typing.Optional[builtins.bool] = None,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+    ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -26854,6 +27105,7 @@ def _typecheckingstub__0fbf37aa0a91cb985ce7a336a6188364cc38400538c1653e53453287c
     cross_zone_enabled: typing.Optional[builtins.bool] = None,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+    ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -27081,6 +27333,7 @@ def _typecheckingstub__eebfbf2a20edd0baf4d455f02dd34d748c5eccfa9a5268e5e2ebec245
     cross_zone_enabled: typing.Optional[builtins.bool] = None,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+    ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
@@ -27354,6 +27607,7 @@ def _typecheckingstub__e179515c9d6138007cc1b74835b75f10a179c1f5ef977cbe4188c778c
     cross_zone_enabled: typing.Optional[builtins.bool] = None,
     deregistration_delay: typing.Optional[_Duration_4839e8c3] = None,
     health_check: typing.Optional[typing.Union[HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+    ip_address_type: typing.Optional[TargetGroupIpAddressType] = None,
     target_group_name: typing.Optional[builtins.str] = None,
     target_type: typing.Optional[TargetType] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,