aws-cdk-lib 2.162.1__py3-none-any.whl → 2.163.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -5923,8 +5923,6 @@ class CfnCapacityProvider(
                 ),
                 managed_termination_protection="managedTerminationProtection"
             ),
-        
-            # the properties below are optional
             name="name",
             tags=[CfnTag(
                 key="key",
@@ -5938,7 +5936,7 @@ class CfnCapacityProvider(
         scope: _constructs_77d1e7e8.Construct,
         id: builtins.str,
         *,
-        auto_scaling_group_provider: typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.AutoScalingGroupProviderProperty", typing.Dict[builtins.str, typing.Any]]],
+        auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.AutoScalingGroupProviderProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
@@ -6006,14 +6004,14 @@ class CfnCapacityProvider(
     @jsii.member(jsii_name="autoScalingGroupProvider")
     def auto_scaling_group_provider(
         self,
-    ) -> typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AutoScalingGroupProviderProperty"]:
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AutoScalingGroupProviderProperty"]]:
         '''The Auto Scaling group settings for the capacity provider.'''
-        return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AutoScalingGroupProviderProperty"], jsii.get(self, "autoScalingGroupProvider"))
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AutoScalingGroupProviderProperty"]], jsii.get(self, "autoScalingGroupProvider"))
 
     @auto_scaling_group_provider.setter
     def auto_scaling_group_provider(
         self,
-        value: typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AutoScalingGroupProviderProperty"],
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AutoScalingGroupProviderProperty"]],
     ) -> None:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__5888da07adc4050987d977b4699983a6760a2abcd538f800018e65953cb2746e)
@@ -6324,7 +6322,7 @@ class CfnCapacityProviderProps:
     def __init__(
         self,
         *,
-        auto_scaling_group_provider: typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]],
+        auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
@@ -6358,8 +6356,6 @@ class CfnCapacityProviderProps:
                     ),
                     managed_termination_protection="managedTerminationProtection"
                 ),
-            
-                # the properties below are optional
                 name="name",
                 tags=[CfnTag(
                     key="key",
@@ -6372,9 +6368,9 @@ class CfnCapacityProviderProps:
             check_type(argname="argument auto_scaling_group_provider", value=auto_scaling_group_provider, expected_type=type_hints["auto_scaling_group_provider"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {
-            "auto_scaling_group_provider": auto_scaling_group_provider,
-        }
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if auto_scaling_group_provider is not None:
+            self._values["auto_scaling_group_provider"] = auto_scaling_group_provider
         if name is not None:
             self._values["name"] = name
         if tags is not None:
@@ -6383,14 +6379,13 @@ class CfnCapacityProviderProps:
     @builtins.property
     def auto_scaling_group_provider(
         self,
-    ) -> typing.Union[_IResolvable_da3f097b, CfnCapacityProvider.AutoScalingGroupProviderProperty]:
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnCapacityProvider.AutoScalingGroupProviderProperty]]:
         '''The Auto Scaling group settings for the capacity provider.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-capacityprovider.html#cfn-ecs-capacityprovider-autoscalinggroupprovider
         '''
         result = self._values.get("auto_scaling_group_provider")
-        assert result is not None, "Required property 'auto_scaling_group_provider' is missing"
-        return typing.cast(typing.Union[_IResolvable_da3f097b, CfnCapacityProvider.AutoScalingGroupProviderProperty], result)
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnCapacityProvider.AutoScalingGroupProviderProperty]], result)
 
     @builtins.property
     def name(self) -> typing.Optional[builtins.str]:
@@ -17659,6 +17654,11 @@ class CfnTaskSet(
             task_definition="taskDefinition",
         
             # the properties below are optional
+            capacity_provider_strategy=[ecs.CfnTaskSet.CapacityProviderStrategyItemProperty(
+                base=123,
+                capacity_provider="capacityProvider",
+                weight=123
+            )],
             external_id="externalId",
             launch_type="launchType",
             load_balancers=[ecs.CfnTaskSet.LoadBalancerProperty(
@@ -17701,6 +17701,7 @@ class CfnTaskSet(
         cluster: builtins.str,
         service: builtins.str,
         task_definition: builtins.str,
+        capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskSet.CapacityProviderStrategyItemProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         external_id: typing.Optional[builtins.str] = None,
         launch_type: typing.Optional[builtins.str] = None,
         load_balancers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskSet.LoadBalancerProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -17716,6 +17717,7 @@ class CfnTaskSet(
         :param cluster: The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
         :param service: The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
         :param task_definition: The task definition for the tasks in the task set to use. If a revision isn't specified, the latest ``ACTIVE`` revision is used.
+        :param capacity_provider_strategy: The capacity provider strategy that are associated with the task set.
         :param external_id: An optional non-unique tag that identifies this task set in external systems. If the task set is associated with a service discovery registry, the tasks in this task set will have the ``ECS_TASK_SET_EXTERNAL_ID`` AWS Cloud Map attribute set to the provided value.
         :param launch_type: The launch type that new tasks in the task set uses. For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* . If a ``launchType`` is specified, the ``capacityProviderStrategy`` parameter must be omitted.
         :param load_balancers: A load balancer object representing the load balancer to use with the task set. The supported load balancer types are either an Application Load Balancer or a Network Load Balancer.
@@ -17733,6 +17735,7 @@ class CfnTaskSet(
             cluster=cluster,
             service=service,
             task_definition=task_definition,
+            capacity_provider_strategy=capacity_provider_strategy,
             external_id=external_id,
             launch_type=launch_type,
             load_balancers=load_balancers,
@@ -17834,6 +17837,24 @@ class CfnTaskSet(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "taskDefinition", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="capacityProviderStrategy")
+    def capacity_provider_strategy(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnTaskSet.CapacityProviderStrategyItemProperty"]]]]:
+        '''The capacity provider strategy that are associated with the task set.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnTaskSet.CapacityProviderStrategyItemProperty"]]]], jsii.get(self, "capacityProviderStrategy"))
+
+    @capacity_provider_strategy.setter
+    def capacity_provider_strategy(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnTaskSet.CapacityProviderStrategyItemProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__61be4a6875e31c55069618271d6dcb0c8c85ffc354777e795c6e004847e90a03)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "capacityProviderStrategy", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="externalId")
     def external_id(self) -> typing.Optional[builtins.str]:
@@ -18064,6 +18085,115 @@ class CfnTaskSet(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnTaskSet.CapacityProviderStrategyItemProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "base": "base",
+            "capacity_provider": "capacityProvider",
+            "weight": "weight",
+        },
+    )
+    class CapacityProviderStrategyItemProperty:
+        def __init__(
+            self,
+            *,
+            base: typing.Optional[jsii.Number] = None,
+            capacity_provider: typing.Optional[builtins.str] = None,
+            weight: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The details of a capacity provider strategy.
+
+            A capacity provider strategy can be set when using the `RunTask <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html>`_ or `CreateCluster <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCluster.html>`_ APIs or as the default capacity provider strategy for a cluster with the ``CreateCluster`` API.
+
+            Only capacity providers that are already associated with a cluster and have an ``ACTIVE`` or ``UPDATING`` status can be used in a capacity provider strategy. The `PutClusterCapacityProviders <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutClusterCapacityProviders.html>`_ API is used to associate a capacity provider with a cluster.
+
+            If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must already be created. New Auto Scaling group capacity providers can be created with the `CreateClusterCapacityProvider <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateClusterCapacityProvider.html>`_ API operation.
+
+            To use a AWS Fargate capacity provider, specify either the ``FARGATE`` or ``FARGATE_SPOT`` capacity providers. The AWS Fargate capacity providers are available to all accounts and only need to be associated with a cluster to be used in a capacity provider strategy.
+
+            With ``FARGATE_SPOT`` , you can run interruption tolerant tasks at a rate that's discounted compared to the ``FARGATE`` price. ``FARGATE_SPOT`` runs tasks on spare compute capacity. When AWS needs the capacity back, your tasks are interrupted with a two-minute warning. ``FARGATE_SPOT`` supports Linux tasks with the X86_64 architecture on platform version 1.3.0 or later. ``FARGATE_SPOT`` supports Linux tasks with the ARM64 architecture on platform version 1.4.0 or later.
+
+            A capacity provider strategy may contain a maximum of 6 capacity providers.
+
+            :param base: The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider. Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of ``0`` is used.
+            :param capacity_provider: The short name of the capacity provider.
+            :param weight: The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The ``weight`` value is taken into consideration after the ``base`` value, if defined, is satisfied. If no ``weight`` value is specified, the default value of ``0`` is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of ``0`` can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of ``0`` , any ``RunTask`` or ``CreateService`` actions using the capacity provider strategy will fail. An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of ``1`` , then when the ``base`` is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of ``1`` for *capacityProviderA* and a weight of ``4`` for *capacityProviderB* , then for every one task that's run using *capacityProviderA* , four tasks would use *capacityProviderB* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskset-capacityproviderstrategyitem.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_ecs as ecs
+                
+                capacity_provider_strategy_item_property = ecs.CfnTaskSet.CapacityProviderStrategyItemProperty(
+                    base=123,
+                    capacity_provider="capacityProvider",
+                    weight=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__1a909a809a339cf5ffe7d2c578b4337c88733f5acf5415a619f79752e216324d)
+                check_type(argname="argument base", value=base, expected_type=type_hints["base"])
+                check_type(argname="argument capacity_provider", value=capacity_provider, expected_type=type_hints["capacity_provider"])
+                check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if base is not None:
+                self._values["base"] = base
+            if capacity_provider is not None:
+                self._values["capacity_provider"] = capacity_provider
+            if weight is not None:
+                self._values["weight"] = weight
+
+        @builtins.property
+        def base(self) -> typing.Optional[jsii.Number]:
+            '''The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider.
+
+            Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of ``0`` is used.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskset-capacityproviderstrategyitem.html#cfn-ecs-taskset-capacityproviderstrategyitem-base
+            '''
+            result = self._values.get("base")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def capacity_provider(self) -> typing.Optional[builtins.str]:
+            '''The short name of the capacity provider.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskset-capacityproviderstrategyitem.html#cfn-ecs-taskset-capacityproviderstrategyitem-capacityprovider
+            '''
+            result = self._values.get("capacity_provider")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def weight(self) -> typing.Optional[jsii.Number]:
+            '''The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider.
+
+            The ``weight`` value is taken into consideration after the ``base`` value, if defined, is satisfied.
+
+            If no ``weight`` value is specified, the default value of ``0`` is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of ``0`` can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of ``0`` , any ``RunTask`` or ``CreateService`` actions using the capacity provider strategy will fail.
+
+            An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of ``1`` , then when the ``base`` is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of ``1`` for *capacityProviderA* and a weight of ``4`` for *capacityProviderB* , then for every one task that's run using *capacityProviderA* , four tasks would use *capacityProviderB* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskset-capacityproviderstrategyitem.html#cfn-ecs-taskset-capacityproviderstrategyitem-weight
+            '''
+            result = self._values.get("weight")
+            return typing.cast(typing.Optional[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 "CapacityProviderStrategyItemProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ecs.CfnTaskSet.LoadBalancerProperty",
         jsii_struct_bases=[],
@@ -18436,6 +18566,7 @@ class CfnTaskSet(
         "cluster": "cluster",
         "service": "service",
         "task_definition": "taskDefinition",
+        "capacity_provider_strategy": "capacityProviderStrategy",
         "external_id": "externalId",
         "launch_type": "launchType",
         "load_balancers": "loadBalancers",
@@ -18453,6 +18584,7 @@ class CfnTaskSetProps:
         cluster: builtins.str,
         service: builtins.str,
         task_definition: builtins.str,
+        capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskSet.CapacityProviderStrategyItemProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
         external_id: typing.Optional[builtins.str] = None,
         launch_type: typing.Optional[builtins.str] = None,
         load_balancers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskSet.LoadBalancerProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -18467,6 +18599,7 @@ class CfnTaskSetProps:
         :param cluster: The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
         :param service: The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
         :param task_definition: The task definition for the tasks in the task set to use. If a revision isn't specified, the latest ``ACTIVE`` revision is used.
+        :param capacity_provider_strategy: The capacity provider strategy that are associated with the task set.
         :param external_id: An optional non-unique tag that identifies this task set in external systems. If the task set is associated with a service discovery registry, the tasks in this task set will have the ``ECS_TASK_SET_EXTERNAL_ID`` AWS Cloud Map attribute set to the provided value.
         :param launch_type: The launch type that new tasks in the task set uses. For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* . If a ``launchType`` is specified, the ``capacityProviderStrategy`` parameter must be omitted.
         :param load_balancers: A load balancer object representing the load balancer to use with the task set. The supported load balancer types are either an Application Load Balancer or a Network Load Balancer.
@@ -18491,6 +18624,11 @@ class CfnTaskSetProps:
                 task_definition="taskDefinition",
             
                 # the properties below are optional
+                capacity_provider_strategy=[ecs.CfnTaskSet.CapacityProviderStrategyItemProperty(
+                    base=123,
+                    capacity_provider="capacityProvider",
+                    weight=123
+                )],
                 external_id="externalId",
                 launch_type="launchType",
                 load_balancers=[ecs.CfnTaskSet.LoadBalancerProperty(
@@ -18529,6 +18667,7 @@ class CfnTaskSetProps:
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
             check_type(argname="argument service", value=service, expected_type=type_hints["service"])
             check_type(argname="argument task_definition", value=task_definition, expected_type=type_hints["task_definition"])
+            check_type(argname="argument capacity_provider_strategy", value=capacity_provider_strategy, expected_type=type_hints["capacity_provider_strategy"])
             check_type(argname="argument external_id", value=external_id, expected_type=type_hints["external_id"])
             check_type(argname="argument launch_type", value=launch_type, expected_type=type_hints["launch_type"])
             check_type(argname="argument load_balancers", value=load_balancers, expected_type=type_hints["load_balancers"])
@@ -18542,6 +18681,8 @@ class CfnTaskSetProps:
             "service": service,
             "task_definition": task_definition,
         }
+        if capacity_provider_strategy is not None:
+            self._values["capacity_provider_strategy"] = capacity_provider_strategy
         if external_id is not None:
             self._values["external_id"] = external_id
         if launch_type is not None:
@@ -18591,6 +18732,17 @@ class CfnTaskSetProps:
         assert result is not None, "Required property 'task_definition' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def capacity_provider_strategy(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTaskSet.CapacityProviderStrategyItemProperty]]]]:
+        '''The capacity provider strategy that are associated with the task set.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-taskset.html#cfn-ecs-taskset-capacityproviderstrategy
+        '''
+        result = self._values.get("capacity_provider_strategy")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTaskSet.CapacityProviderStrategyItemProperty]]]], result)
+
     @builtins.property
     def external_id(self) -> typing.Optional[builtins.str]:
         '''An optional non-unique tag that identifies this task set in external systems.
@@ -41995,7 +42147,7 @@ def _typecheckingstub__59a913caee739f6d41600bf8ae89985db638913fbcb77a8abd5451cda
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
-    auto_scaling_group_provider: typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]],
+    auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
@@ -42015,7 +42167,7 @@ def _typecheckingstub__8ee137a83ca18edf089a21cbcaba0156daf4f4612dbd8c0aeac582bcf
     pass
 
 def _typecheckingstub__5888da07adc4050987d977b4699983a6760a2abcd538f800018e65953cb2746e(
-    value: typing.Union[_IResolvable_da3f097b, CfnCapacityProvider.AutoScalingGroupProviderProperty],
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnCapacityProvider.AutoScalingGroupProviderProperty]],
 ) -> None:
     """Type checking stubs"""
     pass
@@ -42055,7 +42207,7 @@ def _typecheckingstub__b6ba7d15ac2121ea6e10f20fe3e2441ae17d00f30897db384f8f72e7d
 
 def _typecheckingstub__48080bdf05dc1c4ca9ab46c833774163f6afcd0d1551b378b8d59e67bc180c3f(
     *,
-    auto_scaling_group_provider: typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]],
+    auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
@@ -43221,6 +43373,7 @@ def _typecheckingstub__f13a8ecfab3b2d02036a947cd1b4f09594da6ce34103f4abe4f947de6
     cluster: builtins.str,
     service: builtins.str,
     task_definition: builtins.str,
+    capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskSet.CapacityProviderStrategyItemProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     external_id: typing.Optional[builtins.str] = None,
     launch_type: typing.Optional[builtins.str] = None,
     load_balancers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskSet.LoadBalancerProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -43263,6 +43416,12 @@ def _typecheckingstub__94ea8763f334bdea4e67a959b5526084ad4481945c9fb5d1826bab452
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__61be4a6875e31c55069618271d6dcb0c8c85ffc354777e795c6e004847e90a03(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTaskSet.CapacityProviderStrategyItemProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__52f079cf2c2fadbe38461a7e81ef23344c2aa8dbd5c4c1ce147513deec1f10f7(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -43320,6 +43479,15 @@ def _typecheckingstub__23e9c54f36446bdd091ba5f810830e55216485324451c353fdf9f5f97
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__1a909a809a339cf5ffe7d2c578b4337c88733f5acf5415a619f79752e216324d(
+    *,
+    base: typing.Optional[jsii.Number] = None,
+    capacity_provider: typing.Optional[builtins.str] = None,
+    weight: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__0f830dadc8709f058eb9f85bc90e372f1fe6c9eb7e45fdb293a2baf917f771ae(
     *,
     container_name: typing.Optional[builtins.str] = None,
@@ -43359,6 +43527,7 @@ def _typecheckingstub__a26a1ad2b86b6633517c82faa438939dc6de131055ef873e022a9725a
     cluster: builtins.str,
     service: builtins.str,
     task_definition: builtins.str,
+    capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskSet.CapacityProviderStrategyItemProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     external_id: typing.Optional[builtins.str] = None,
     launch_type: typing.Optional[builtins.str] = None,
     load_balancers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskSet.LoadBalancerProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,