aws-cdk-lib 2.148.1__py3-none-any.whl → 2.149.0__py3-none-any.whl

aws_cdk/aws_codedeploy/__init__.py

@@ -204,6 +204,25 @@ Or import an existing one:
 deployment_config = codedeploy.ServerDeploymentConfig.from_server_deployment_config_name(self, "ExistingDeploymentConfiguration", "MyExistingDeploymentConfiguration")
 ```
 
+### Zonal Configuration
+
+CodeDeploy can deploy your application to one Availability Zone at a time, within an AWS Region by configuring [zonal configuration](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations-create.html#zonal-config).
+
+To create a new deployment configuration with zonal configuration:
+
+```python
+deployment_config = codedeploy.ServerDeploymentConfig(self, "DeploymentConfiguration",
+    minimum_healthy_hosts=codedeploy.MinimumHealthyHosts.count(2),
+    zonal_config=codedeploy.ZonalConfig(
+        monitor_duration=Duration.minutes(30),
+        first_zone_monitor_duration=Duration.minutes(60),
+        minimum_healthy_hosts_per_zone=codedeploy.MinimumHealthyHostsPerZone.count(1)
+    )
+)
+```
+
+**Note**: Zonal configuration is only configurable for EC2/on-premise deployments.
+
 ## Lambda Applications
 
 To create a new CodeDeploy Application that deploys to a Lambda function:
@@ -982,6 +1001,7 @@ class BaseDeploymentConfigOptions:
         "compute_platform": "computePlatform",
         "minimum_healthy_hosts": "minimumHealthyHosts",
         "traffic_routing": "trafficRouting",
+        "zonal_config": "zonalConfig",
     },
 )
 class BaseDeploymentConfigProps(BaseDeploymentConfigOptions):
@@ -992,6 +1012,7 @@ class BaseDeploymentConfigProps(BaseDeploymentConfigOptions):
         compute_platform: typing.Optional["ComputePlatform"] = None,
         minimum_healthy_hosts: typing.Optional["MinimumHealthyHosts"] = None,
         traffic_routing: typing.Optional["TrafficRouting"] = None,
+        zonal_config: typing.Optional[typing.Union["ZonalConfig", typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''Complete base deployment config properties that are required to be supplied by the implementation of the BaseDeploymentConfig class.
 
@@ -999,6 +1020,7 @@ class BaseDeploymentConfigProps(BaseDeploymentConfigOptions):
         :param compute_platform: The destination compute platform for the deployment. Default: ComputePlatform.Server
         :param minimum_healthy_hosts: Minimum number of healthy hosts. Default: None
         :param traffic_routing: The configuration that specifies how traffic is shifted during a deployment. Only applicable to ECS and Lambda deployments, and must not be specified for Server deployments. Default: None
+        :param zonal_config: Configure CodeDeploy to deploy your application to one Availability Zone at a time within an AWS Region. Default: - deploy your application to a random selection of hosts across a Region
 
         :exampleMetadata: fixture=_generated
 
@@ -1006,24 +1028,34 @@ class BaseDeploymentConfigProps(BaseDeploymentConfigOptions):
 
             # 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_codedeploy as codedeploy
             
             # minimum_healthy_hosts: codedeploy.MinimumHealthyHosts
+            # minimum_healthy_hosts_per_zone: codedeploy.MinimumHealthyHostsPerZone
             # traffic_routing: codedeploy.TrafficRouting
             
             base_deployment_config_props = codedeploy.BaseDeploymentConfigProps(
                 compute_platform=codedeploy.ComputePlatform.SERVER,
                 deployment_config_name="deploymentConfigName",
                 minimum_healthy_hosts=minimum_healthy_hosts,
-                traffic_routing=traffic_routing
+                traffic_routing=traffic_routing,
+                zonal_config=codedeploy.ZonalConfig(
+                    first_zone_monitor_duration=cdk.Duration.minutes(30),
+                    minimum_healthy_hosts_per_zone=minimum_healthy_hosts_per_zone,
+                    monitor_duration=cdk.Duration.minutes(30)
+                )
             )
         '''
+        if isinstance(zonal_config, dict):
+            zonal_config = ZonalConfig(**zonal_config)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__d482592e3c5f65fb9559b3e230fe81eab72a36fdd6c5a5b3cad1b4206b327f9f)
             check_type(argname="argument deployment_config_name", value=deployment_config_name, expected_type=type_hints["deployment_config_name"])
             check_type(argname="argument compute_platform", value=compute_platform, expected_type=type_hints["compute_platform"])
             check_type(argname="argument minimum_healthy_hosts", value=minimum_healthy_hosts, expected_type=type_hints["minimum_healthy_hosts"])
             check_type(argname="argument traffic_routing", value=traffic_routing, expected_type=type_hints["traffic_routing"])
+            check_type(argname="argument zonal_config", value=zonal_config, expected_type=type_hints["zonal_config"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if deployment_config_name is not None:
             self._values["deployment_config_name"] = deployment_config_name
@@ -1033,6 +1065,8 @@ class BaseDeploymentConfigProps(BaseDeploymentConfigOptions):
             self._values["minimum_healthy_hosts"] = minimum_healthy_hosts
         if traffic_routing is not None:
             self._values["traffic_routing"] = traffic_routing
+        if zonal_config is not None:
+            self._values["zonal_config"] = zonal_config
 
     @builtins.property
     def deployment_config_name(self) -> typing.Optional[builtins.str]:
@@ -1072,6 +1106,17 @@ class BaseDeploymentConfigProps(BaseDeploymentConfigOptions):
         result = self._values.get("traffic_routing")
         return typing.cast(typing.Optional["TrafficRouting"], result)
 
+    @builtins.property
+    def zonal_config(self) -> typing.Optional["ZonalConfig"]:
+        '''Configure CodeDeploy to deploy your application to one Availability Zone at a time within an AWS Region.
+
+        :default: - deploy your application to a random selection of hosts across a Region
+
+        :see: https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations-create.html#zonal-config
+        '''
+        result = self._values.get("zonal_config")
+        return typing.cast(typing.Optional["ZonalConfig"], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -7990,7 +8035,7 @@ class MinimumHealthyHosts(
     @jsii.member(jsii_name="count")
     @builtins.classmethod
     def count(cls, value: jsii.Number) -> "MinimumHealthyHosts":
-        '''The minimum healhty hosts threshold expressed as an absolute number.
+        '''The minimum healthy hosts threshold expressed as an absolute number.
 
         :param value: -
         '''
@@ -8002,7 +8047,7 @@ class MinimumHealthyHosts(
     @jsii.member(jsii_name="percentage")
     @builtins.classmethod
     def percentage(cls, value: jsii.Number) -> "MinimumHealthyHosts":
-        '''The minmum healhty hosts threshold expressed as a percentage of the fleet.
+        '''The minimum healthy hosts threshold expressed as a percentage of the fleet.
 
         :param value: -
         '''
@@ -8012,6 +8057,51 @@ class MinimumHealthyHosts(
         return typing.cast("MinimumHealthyHosts", jsii.sinvoke(cls, "percentage", [value]))
 
 
+class MinimumHealthyHostsPerZone(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_codedeploy.MinimumHealthyHostsPerZone",
+):
+    '''Minimum number of healthy hosts per availability zone for a server deployment.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        deployment_config = codedeploy.ServerDeploymentConfig(self, "DeploymentConfiguration",
+            minimum_healthy_hosts=codedeploy.MinimumHealthyHosts.count(2),
+            zonal_config=codedeploy.ZonalConfig(
+                monitor_duration=Duration.minutes(30),
+                first_zone_monitor_duration=Duration.minutes(60),
+                minimum_healthy_hosts_per_zone=codedeploy.MinimumHealthyHostsPerZone.count(1)
+            )
+        )
+    '''
+
+    @jsii.member(jsii_name="count")
+    @builtins.classmethod
+    def count(cls, value: jsii.Number) -> "MinimumHealthyHostsPerZone":
+        '''The minimum healthy hosts threshold expressed as an absolute number.
+
+        :param value: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__eccc54cbc4cc48bc8d4e0d61ba6ab67a555a3dd8c67ba3c554298b4550ec6f59)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        return typing.cast("MinimumHealthyHostsPerZone", jsii.sinvoke(cls, "count", [value]))
+
+    @jsii.member(jsii_name="percentage")
+    @builtins.classmethod
+    def percentage(cls, value: jsii.Number) -> "MinimumHealthyHostsPerZone":
+        '''The minimum healthy hosts threshold expressed as a percentage of the fleet.
+
+        :param value: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__75bdd06c1ec9d52232bc0151dd7dbfd975c0fe0a98b66121298028c191aae9e1)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        return typing.cast("MinimumHealthyHostsPerZone", jsii.sinvoke(cls, "percentage", [value]))
+
+
 @jsii.implements(IServerApplication)
 class ServerApplication(
     _Resource_45bc6135,
@@ -8167,6 +8257,7 @@ class ServerApplicationProps:
     name_mapping={
         "deployment_config_name": "deploymentConfigName",
         "minimum_healthy_hosts": "minimumHealthyHosts",
+        "zonal_config": "zonalConfig",
     },
 )
 class ServerDeploymentConfigProps(BaseDeploymentConfigOptions):
@@ -8175,11 +8266,13 @@ class ServerDeploymentConfigProps(BaseDeploymentConfigOptions):
         *,
         deployment_config_name: typing.Optional[builtins.str] = None,
         minimum_healthy_hosts: MinimumHealthyHosts,
+        zonal_config: typing.Optional[typing.Union["ZonalConfig", typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''Construction properties of ``ServerDeploymentConfig``.
 
         :param deployment_config_name: The physical, human-readable name of the Deployment Configuration. Default: - automatically generated name
         :param minimum_healthy_hosts: Minimum number of healthy hosts.
+        :param zonal_config: Configure CodeDeploy to deploy your application to one Availability Zone at a time within an AWS Region. Default: - deploy your application to a random selection of hosts across a Region
 
         :exampleMetadata: infused
 
@@ -8191,15 +8284,20 @@ class ServerDeploymentConfigProps(BaseDeploymentConfigOptions):
                 minimum_healthy_hosts=codedeploy.MinimumHealthyHosts.count(2)
             )
         '''
+        if isinstance(zonal_config, dict):
+            zonal_config = ZonalConfig(**zonal_config)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__46be421d00313823efbbb0072b871dc311f7d9fca8dee4c13562ddd078f8cd37)
             check_type(argname="argument deployment_config_name", value=deployment_config_name, expected_type=type_hints["deployment_config_name"])
             check_type(argname="argument minimum_healthy_hosts", value=minimum_healthy_hosts, expected_type=type_hints["minimum_healthy_hosts"])
+            check_type(argname="argument zonal_config", value=zonal_config, expected_type=type_hints["zonal_config"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "minimum_healthy_hosts": minimum_healthy_hosts,
         }
         if deployment_config_name is not None:
             self._values["deployment_config_name"] = deployment_config_name
+        if zonal_config is not None:
+            self._values["zonal_config"] = zonal_config
 
     @builtins.property
     def deployment_config_name(self) -> typing.Optional[builtins.str]:
@@ -8217,6 +8315,15 @@ class ServerDeploymentConfigProps(BaseDeploymentConfigOptions):
         assert result is not None, "Required property 'minimum_healthy_hosts' is missing"
         return typing.cast(MinimumHealthyHosts, result)
 
+    @builtins.property
+    def zonal_config(self) -> typing.Optional["ZonalConfig"]:
+        '''Configure CodeDeploy to deploy your application to one Availability Zone at a time within an AWS Region.
+
+        :default: - deploy your application to a random selection of hosts across a Region
+        '''
+        result = self._values.get("zonal_config")
+        return typing.cast(typing.Optional["ZonalConfig"], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -9109,6 +9216,110 @@ class TrafficRoutingConfig:
         )
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_codedeploy.ZonalConfig",
+    jsii_struct_bases=[],
+    name_mapping={
+        "first_zone_monitor_duration": "firstZoneMonitorDuration",
+        "minimum_healthy_hosts_per_zone": "minimumHealthyHostsPerZone",
+        "monitor_duration": "monitorDuration",
+    },
+)
+class ZonalConfig:
+    def __init__(
+        self,
+        *,
+        first_zone_monitor_duration: typing.Optional[_Duration_4839e8c3] = None,
+        minimum_healthy_hosts_per_zone: typing.Optional[MinimumHealthyHostsPerZone] = None,
+        monitor_duration: typing.Optional[_Duration_4839e8c3] = None,
+    ) -> None:
+        '''Configuration for CodeDeploy to deploy your application to one Availability Zone at a time within an AWS Region.
+
+        :param first_zone_monitor_duration: The period of time that CodeDeploy must wait after completing a deployment to the first Availability Zone. Accepted Values: - 0 - Greater than or equal to 1 Default: - the same value as ``monitorDuration``
+        :param minimum_healthy_hosts_per_zone: The number or percentage of instances that must remain available per Availability Zone during a deployment. This option works in conjunction with the ``minimumHealthyHosts`` option. Default: - 0 percent
+        :param monitor_duration: The period of time that CodeDeploy must wait after completing a deployment to an Availability Zone. Accepted Values: - 0 - Greater than or equal to 1 Default: - CodeDeploy starts deploying to the next Availability Zone immediately
+
+        :exampleMetadata: infused
+
+        Example::
+
+            deployment_config = codedeploy.ServerDeploymentConfig(self, "DeploymentConfiguration",
+                minimum_healthy_hosts=codedeploy.MinimumHealthyHosts.count(2),
+                zonal_config=codedeploy.ZonalConfig(
+                    monitor_duration=Duration.minutes(30),
+                    first_zone_monitor_duration=Duration.minutes(60),
+                    minimum_healthy_hosts_per_zone=codedeploy.MinimumHealthyHostsPerZone.count(1)
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4e3b953d8872e36c383f9e09cfb712143f81f7357675dc0a7a44b700b05d5168)
+            check_type(argname="argument first_zone_monitor_duration", value=first_zone_monitor_duration, expected_type=type_hints["first_zone_monitor_duration"])
+            check_type(argname="argument minimum_healthy_hosts_per_zone", value=minimum_healthy_hosts_per_zone, expected_type=type_hints["minimum_healthy_hosts_per_zone"])
+            check_type(argname="argument monitor_duration", value=monitor_duration, expected_type=type_hints["monitor_duration"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if first_zone_monitor_duration is not None:
+            self._values["first_zone_monitor_duration"] = first_zone_monitor_duration
+        if minimum_healthy_hosts_per_zone is not None:
+            self._values["minimum_healthy_hosts_per_zone"] = minimum_healthy_hosts_per_zone
+        if monitor_duration is not None:
+            self._values["monitor_duration"] = monitor_duration
+
+    @builtins.property
+    def first_zone_monitor_duration(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The period of time that CodeDeploy must wait after completing a deployment to the first Availability Zone.
+
+        Accepted Values:
+
+        - 0
+        - Greater than or equal to 1
+
+        :default: - the same value as ``monitorDuration``
+        '''
+        result = self._values.get("first_zone_monitor_duration")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
+    @builtins.property
+    def minimum_healthy_hosts_per_zone(
+        self,
+    ) -> typing.Optional[MinimumHealthyHostsPerZone]:
+        '''The number or percentage of instances that must remain available per Availability Zone during a deployment.
+
+        This option works in conjunction with the ``minimumHealthyHosts`` option.
+
+        :default: - 0 percent
+
+        :see: https://docs.aws.amazon.com/codedeploy/latest/userguide/instances-health.html#minimum-healthy-hosts-az
+        '''
+        result = self._values.get("minimum_healthy_hosts_per_zone")
+        return typing.cast(typing.Optional[MinimumHealthyHostsPerZone], result)
+
+    @builtins.property
+    def monitor_duration(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The period of time that CodeDeploy must wait after completing a deployment to an Availability Zone.
+
+        Accepted Values:
+
+        - 0
+        - Greater than or equal to 1
+
+        :default: - CodeDeploy starts deploying to the next Availability Zone immediately
+        '''
+        result = self._values.get("monitor_duration")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], 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 "ZonalConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 class AllAtOnceTrafficRouting(
     TrafficRouting,
     metaclass=jsii.JSIIMeta,
@@ -9161,6 +9372,7 @@ class BaseDeploymentConfig(
         compute_platform: typing.Optional[ComputePlatform] = None,
         minimum_healthy_hosts: typing.Optional[MinimumHealthyHosts] = None,
         traffic_routing: typing.Optional[TrafficRouting] = None,
+        zonal_config: typing.Optional[typing.Union[ZonalConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_config_name: typing.Optional[builtins.str] = None,
     ) -> None:
         '''
@@ -9169,6 +9381,7 @@ class BaseDeploymentConfig(
         :param compute_platform: The destination compute platform for the deployment. Default: ComputePlatform.Server
         :param minimum_healthy_hosts: Minimum number of healthy hosts. Default: None
         :param traffic_routing: The configuration that specifies how traffic is shifted during a deployment. Only applicable to ECS and Lambda deployments, and must not be specified for Server deployments. Default: None
+        :param zonal_config: Configure CodeDeploy to deploy your application to one Availability Zone at a time within an AWS Region. Default: - deploy your application to a random selection of hosts across a Region
         :param deployment_config_name: The physical, human-readable name of the Deployment Configuration. Default: - automatically generated name
         '''
         if __debug__:
@@ -9179,6 +9392,7 @@ class BaseDeploymentConfig(
             compute_platform=compute_platform,
             minimum_healthy_hosts=minimum_healthy_hosts,
             traffic_routing=traffic_routing,
+            zonal_config=zonal_config,
             deployment_config_name=deployment_config_name,
         )
 
@@ -9899,8 +10113,10 @@ class ServerDeploymentConfig(
 
     Example::
 
-        deployment_group = codedeploy.ServerDeploymentGroup(self, "CodeDeployDeploymentGroup",
-            deployment_config=codedeploy.ServerDeploymentConfig.ALL_AT_ONCE
+        deployment_config = codedeploy.ServerDeploymentConfig(self, "DeploymentConfiguration",
+            deployment_config_name="MyDeploymentConfiguration",  # optional property
+            # one of these is required, but both cannot be specified at the same time
+            minimum_healthy_hosts=codedeploy.MinimumHealthyHosts.count(2)
         )
     '''
 
@@ -9910,12 +10126,14 @@ class ServerDeploymentConfig(
         id: builtins.str,
         *,
         minimum_healthy_hosts: MinimumHealthyHosts,
+        zonal_config: typing.Optional[typing.Union[ZonalConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_config_name: typing.Optional[builtins.str] = None,
     ) -> None:
         '''
         :param scope: -
         :param id: -
         :param minimum_healthy_hosts: Minimum number of healthy hosts.
+        :param zonal_config: Configure CodeDeploy to deploy your application to one Availability Zone at a time within an AWS Region. Default: - deploy your application to a random selection of hosts across a Region
         :param deployment_config_name: The physical, human-readable name of the Deployment Configuration. Default: - automatically generated name
         '''
         if __debug__:
@@ -9924,6 +10142,7 @@ class ServerDeploymentConfig(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = ServerDeploymentConfigProps(
             minimum_healthy_hosts=minimum_healthy_hosts,
+            zonal_config=zonal_config,
             deployment_config_name=deployment_config_name,
         )
 
@@ -10147,6 +10366,7 @@ __all__ = [
     "LoadBalancer",
     "LoadBalancerGeneration",
     "MinimumHealthyHosts",
+    "MinimumHealthyHostsPerZone",
     "ServerApplication",
     "ServerApplicationProps",
     "ServerDeploymentConfig",
@@ -10160,6 +10380,7 @@ __all__ = [
     "TimeBasedLinearTrafficRoutingProps",
     "TrafficRouting",
     "TrafficRoutingConfig",
+    "ZonalConfig",
 ]
 
 publication.publish()
@@ -10186,6 +10407,7 @@ def _typecheckingstub__d482592e3c5f65fb9559b3e230fe81eab72a36fdd6c5a5b3cad1b4206
     compute_platform: typing.Optional[ComputePlatform] = None,
     minimum_healthy_hosts: typing.Optional[MinimumHealthyHosts] = None,
     traffic_routing: typing.Optional[TrafficRouting] = None,
+    zonal_config: typing.Optional[typing.Union[ZonalConfig, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -10994,6 +11216,18 @@ def _typecheckingstub__6c2a97036f753857be857236ee3fb97ddf235514bd9c31466fb2e5691
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__eccc54cbc4cc48bc8d4e0d61ba6ab67a555a3dd8c67ba3c554298b4550ec6f59(
+    value: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__75bdd06c1ec9d52232bc0151dd7dbfd975c0fe0a98b66121298028c191aae9e1(
+    value: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ff491d45a3da21d4d70991ac332ef8f240b72138a59519fcf6c3da3a3a9cb970(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -11030,6 +11264,7 @@ def _typecheckingstub__46be421d00313823efbbb0072b871dc311f7d9fca8dee4c13562ddd07
     *,
     deployment_config_name: typing.Optional[builtins.str] = None,
     minimum_healthy_hosts: MinimumHealthyHosts,
+    zonal_config: typing.Optional[typing.Union[ZonalConfig, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -11141,6 +11376,15 @@ def _typecheckingstub__b845a8828051dc720d79c0332ea3470f754dd765be05c704a97b65823
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__4e3b953d8872e36c383f9e09cfb712143f81f7357675dc0a7a44b700b05d5168(
+    *,
+    first_zone_monitor_duration: typing.Optional[_Duration_4839e8c3] = None,
+    minimum_healthy_hosts_per_zone: typing.Optional[MinimumHealthyHostsPerZone] = None,
+    monitor_duration: typing.Optional[_Duration_4839e8c3] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__f05ebc00e48366a13e2ad293e1822da6d979a050647a74d9f563aab403921d0d(
     _scope: _constructs_77d1e7e8.Construct,
 ) -> None:
@@ -11154,6 +11398,7 @@ def _typecheckingstub__f7be4ac008b1dbe1f91bb986ac7bb32dd779f4962b7a7696d9064b17f
     compute_platform: typing.Optional[ComputePlatform] = None,
     minimum_healthy_hosts: typing.Optional[MinimumHealthyHosts] = None,
     traffic_routing: typing.Optional[TrafficRouting] = None,
+    zonal_config: typing.Optional[typing.Union[ZonalConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_config_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -11289,6 +11534,7 @@ def _typecheckingstub__0188bedb6550f8f8ec5175aae5830d1c200a93e114c45fc9d6b3942b7
     id: builtins.str,
     *,
     minimum_healthy_hosts: MinimumHealthyHosts,
+    zonal_config: typing.Optional[typing.Union[ZonalConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_config_name: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""