pulumi-aws-native 1.39.0a1762385303__py3-none-any.whl → 1.39.0a1762580459__py3-none-any.whl

pulumi_aws_native/datazone/outputs.py

@@ -17,6 +17,7 @@ from . import outputs
 from ._enums import *
 
 __all__ = [
+    'ConnectionAmazonQPropertiesInput',
     'ConnectionAthenaPropertiesInput',
     'ConnectionAuthenticationConfigurationInput',
     'ConnectionAuthorizationCodeProperties',
@@ -39,6 +40,7 @@ __all__ = [
     'ConnectionPropertiesInput5Properties',
     'ConnectionPropertiesInput6Properties',
     'ConnectionPropertiesInput7Properties',
+    'ConnectionPropertiesInput8Properties',
     'ConnectionRedshiftCredentials0Properties',
     'ConnectionRedshiftCredentials1Properties',
     'ConnectionRedshiftLineageSyncConfigurationInput',
@@ -129,6 +131,70 @@ __all__ = [
     'UserProfileSsoUserProfileDetails',
 ]
 
+@pulumi.output_type
+class ConnectionAmazonQPropertiesInput(dict):
+    """
+    Amazon Q properties of the connection.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authMode":
+            suggest = "auth_mode"
+        elif key == "isEnabled":
+            suggest = "is_enabled"
+        elif key == "profileArn":
+            suggest = "profile_arn"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionAmazonQPropertiesInput. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionAmazonQPropertiesInput.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionAmazonQPropertiesInput.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 auth_mode: Optional[_builtins.str] = None,
+                 is_enabled: Optional[_builtins.bool] = None,
+                 profile_arn: Optional[_builtins.str] = None):
+        """
+        Amazon Q properties of the connection.
+        :param _builtins.str auth_mode: The authentication mode of the connection's AmazonQ properties
+        :param _builtins.bool is_enabled: Specifies whether Amazon Q is enabled for the connection
+        """
+        if auth_mode is not None:
+            pulumi.set(__self__, "auth_mode", auth_mode)
+        if is_enabled is not None:
+            pulumi.set(__self__, "is_enabled", is_enabled)
+        if profile_arn is not None:
+            pulumi.set(__self__, "profile_arn", profile_arn)
+
+    @_builtins.property
+    @pulumi.getter(name="authMode")
+    def auth_mode(self) -> Optional[_builtins.str]:
+        """
+        The authentication mode of the connection's AmazonQ properties
+        """
+        return pulumi.get(self, "auth_mode")
+
+    @_builtins.property
+    @pulumi.getter(name="isEnabled")
+    def is_enabled(self) -> Optional[_builtins.bool]:
+        """
+        Specifies whether Amazon Q is enabled for the connection
+        """
+        return pulumi.get(self, "is_enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="profileArn")
+    def profile_arn(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "profile_arn")
+
+
 @pulumi.output_type
 class ConnectionAthenaPropertiesInput(dict):
     """
@@ -1133,8 +1199,8 @@ class ConnectionPropertiesInput6Properties(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "sparkGlueProperties":
-            suggest = "spark_glue_properties"
+        if key == "amazonQProperties":
+            suggest = "amazon_q_properties"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ConnectionPropertiesInput6Properties. Access the value via the '{suggest}' property getter instead.")
@@ -1147,6 +1213,35 @@ class ConnectionPropertiesInput6Properties(dict):
         ConnectionPropertiesInput6Properties.__key_warning(key)
         return super().get(key, default)
 
+    def __init__(__self__, *,
+                 amazon_q_properties: 'outputs.ConnectionAmazonQPropertiesInput'):
+        pulumi.set(__self__, "amazon_q_properties", amazon_q_properties)
+
+    @_builtins.property
+    @pulumi.getter(name="amazonQProperties")
+    def amazon_q_properties(self) -> 'outputs.ConnectionAmazonQPropertiesInput':
+        return pulumi.get(self, "amazon_q_properties")
+
+
+@pulumi.output_type
+class ConnectionPropertiesInput7Properties(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sparkGlueProperties":
+            suggest = "spark_glue_properties"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionPropertiesInput7Properties. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ConnectionPropertiesInput7Properties.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ConnectionPropertiesInput7Properties.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
                  spark_glue_properties: 'outputs.ConnectionSparkGluePropertiesInput'):
         pulumi.set(__self__, "spark_glue_properties", spark_glue_properties)
@@ -1158,7 +1253,7 @@ class ConnectionPropertiesInput6Properties(dict):
 
 
 @pulumi.output_type
-class ConnectionPropertiesInput7Properties(dict):
+class ConnectionPropertiesInput8Properties(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
@@ -1166,14 +1261,14 @@ class ConnectionPropertiesInput7Properties(dict):
             suggest = "s3_properties"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ConnectionPropertiesInput7Properties. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ConnectionPropertiesInput8Properties. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ConnectionPropertiesInput7Properties.__key_warning(key)
+        ConnectionPropertiesInput8Properties.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ConnectionPropertiesInput7Properties.__key_warning(key)
+        ConnectionPropertiesInput8Properties.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,

pulumi_aws_native/dynamodb/_inputs.py

@@ -1303,7 +1303,7 @@ class GlobalTableReplicaSseSpecificationArgs:
 
 if not MYPY:
     class GlobalTableReplicaStreamSpecificationArgsDict(TypedDict):
-        resource_policy: pulumi.Input['GlobalTableResourcePolicyArgsDict']
+        resource_policy: NotRequired[pulumi.Input['GlobalTableResourcePolicyArgsDict']]
         """
         A resource-based policy document that contains the permissions for the specified stream of a DynamoDB global table replica. Resource-based policies let you define access permissions by specifying who has access to each resource, and the actions they are allowed to perform on each resource.
 
@@ -1317,7 +1317,7 @@ elif False:
 @pulumi.input_type
 class GlobalTableReplicaStreamSpecificationArgs:
     def __init__(__self__, *,
-                 resource_policy: pulumi.Input['GlobalTableResourcePolicyArgs']):
+                 resource_policy: Optional[pulumi.Input['GlobalTableResourcePolicyArgs']] = None):
         """
         :param pulumi.Input['GlobalTableResourcePolicyArgs'] resource_policy: A resource-based policy document that contains the permissions for the specified stream of a DynamoDB global table replica. Resource-based policies let you define access permissions by specifying who has access to each resource, and the actions they are allowed to perform on each resource.
                
@@ -1325,11 +1325,12 @@ class GlobalTableReplicaStreamSpecificationArgs:
                
                You can update the `ResourcePolicy` property if you've specified more than one table using the [AWS ::DynamoDB::GlobalTable](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-globaltable.html) resource.
         """
-        pulumi.set(__self__, "resource_policy", resource_policy)
+        if resource_policy is not None:
+            pulumi.set(__self__, "resource_policy", resource_policy)
 
     @_builtins.property
     @pulumi.getter(name="resourcePolicy")
-    def resource_policy(self) -> pulumi.Input['GlobalTableResourcePolicyArgs']:
+    def resource_policy(self) -> Optional[pulumi.Input['GlobalTableResourcePolicyArgs']]:
         """
         A resource-based policy document that contains the permissions for the specified stream of a DynamoDB global table replica. Resource-based policies let you define access permissions by specifying who has access to each resource, and the actions they are allowed to perform on each resource.
 
@@ -1340,7 +1341,7 @@ class GlobalTableReplicaStreamSpecificationArgs:
         return pulumi.get(self, "resource_policy")
 
     @resource_policy.setter
-    def resource_policy(self, value: pulumi.Input['GlobalTableResourcePolicyArgs']):
+    def resource_policy(self, value: Optional[pulumi.Input['GlobalTableResourcePolicyArgs']]):
         pulumi.set(self, "resource_policy", value)
 
 

pulumi_aws_native/dynamodb/outputs.py

@@ -1072,7 +1072,7 @@ class GlobalTableReplicaStreamSpecification(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 resource_policy: 'outputs.GlobalTableResourcePolicy'):
+                 resource_policy: Optional['outputs.GlobalTableResourcePolicy'] = None):
         """
         :param 'GlobalTableResourcePolicy' resource_policy: A resource-based policy document that contains the permissions for the specified stream of a DynamoDB global table replica. Resource-based policies let you define access permissions by specifying who has access to each resource, and the actions they are allowed to perform on each resource.
                
@@ -1080,11 +1080,12 @@ class GlobalTableReplicaStreamSpecification(dict):
                
                You can update the `ResourcePolicy` property if you've specified more than one table using the [AWS ::DynamoDB::GlobalTable](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-globaltable.html) resource.
         """
-        pulumi.set(__self__, "resource_policy", resource_policy)
+        if resource_policy is not None:
+            pulumi.set(__self__, "resource_policy", resource_policy)
 
     @_builtins.property
     @pulumi.getter(name="resourcePolicy")
-    def resource_policy(self) -> 'outputs.GlobalTableResourcePolicy':
+    def resource_policy(self) -> Optional['outputs.GlobalTableResourcePolicy']:
         """
         A resource-based policy document that contains the permissions for the specified stream of a DynamoDB global table replica. Resource-based policies let you define access permissions by specifying who has access to each resource, and the actions they are allowed to perform on each resource.
 

pulumi_aws_native/ecr/_inputs.py

@@ -426,7 +426,7 @@ class RepositoryCreationTemplateEncryptionConfigurationArgs:
 if not MYPY:
     class RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgsDict(TypedDict):
         """
-        Overrides the default image tag mutability setting of the repository for image tags that match the specified filters.
+        A filter that specifies which image tags should be excluded from the repository's image tag mutability setting.
         """
         image_tag_mutability_exclusion_filter_type: pulumi.Input['RepositoryCreationTemplateImageTagMutabilityExclusionFilterImageTagMutabilityExclusionFilterType']
         image_tag_mutability_exclusion_filter_value: pulumi.Input[_builtins.str]
@@ -439,7 +439,7 @@ class RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgs:
                  image_tag_mutability_exclusion_filter_type: pulumi.Input['RepositoryCreationTemplateImageTagMutabilityExclusionFilterImageTagMutabilityExclusionFilterType'],
                  image_tag_mutability_exclusion_filter_value: pulumi.Input[_builtins.str]):
         """
-        Overrides the default image tag mutability setting of the repository for image tags that match the specified filters.
+        A filter that specifies which image tags should be excluded from the repository's image tag mutability setting.
         """
         pulumi.set(__self__, "image_tag_mutability_exclusion_filter_type", image_tag_mutability_exclusion_filter_type)
         pulumi.set(__self__, "image_tag_mutability_exclusion_filter_value", image_tag_mutability_exclusion_filter_value)

pulumi_aws_native/ecr/get_repository_creation_template.py

@@ -112,7 +112,7 @@ class GetRepositoryCreationTemplateResult:
     @pulumi.getter(name="imageTagMutabilityExclusionFilters")
     def image_tag_mutability_exclusion_filters(self) -> Optional[Sequence['outputs.RepositoryCreationTemplateImageTagMutabilityExclusionFilter']]:
         """
-        Defines the image tag mutability exclusion filters to apply when creating repositories from this template. These filters specify which image tags can override the repository's default image tag mutability setting.
+        A list of filters that specify which image tags are excluded from the repository creation template's image tag mutability setting.
         """
         return pulumi.get(self, "image_tag_mutability_exclusion_filters")
 

pulumi_aws_native/ecr/outputs.py

@@ -375,7 +375,7 @@ class RepositoryCreationTemplateEncryptionConfiguration(dict):
 @pulumi.output_type
 class RepositoryCreationTemplateImageTagMutabilityExclusionFilter(dict):
     """
-    Overrides the default image tag mutability setting of the repository for image tags that match the specified filters.
+    A filter that specifies which image tags should be excluded from the repository's image tag mutability setting.
     """
     @staticmethod
     def __key_warning(key: str):
@@ -400,7 +400,7 @@ class RepositoryCreationTemplateImageTagMutabilityExclusionFilter(dict):
                  image_tag_mutability_exclusion_filter_type: 'RepositoryCreationTemplateImageTagMutabilityExclusionFilterImageTagMutabilityExclusionFilterType',
                  image_tag_mutability_exclusion_filter_value: _builtins.str):
         """
-        Overrides the default image tag mutability setting of the repository for image tags that match the specified filters.
+        A filter that specifies which image tags should be excluded from the repository's image tag mutability setting.
         """
         pulumi.set(__self__, "image_tag_mutability_exclusion_filter_type", image_tag_mutability_exclusion_filter_type)
         pulumi.set(__self__, "image_tag_mutability_exclusion_filter_value", image_tag_mutability_exclusion_filter_value)

pulumi_aws_native/ecr/repository_creation_template.py

@@ -40,7 +40,7 @@ class RepositoryCreationTemplateArgs:
         :param pulumi.Input[_builtins.str] description: The description associated with the repository creation template.
         :param pulumi.Input['RepositoryCreationTemplateEncryptionConfigurationArgs'] encryption_configuration: The encryption configuration associated with the repository creation template.
         :param pulumi.Input['RepositoryCreationTemplateImageTagMutability'] image_tag_mutability: The tag mutability setting for the repository. If this parameter is omitted, the default setting of ``MUTABLE`` will be used which will allow image tags to be overwritten. If ``IMMUTABLE`` is specified, all image tags within the repository will be immutable which will prevent them from being overwritten.
-        :param pulumi.Input[Sequence[pulumi.Input['RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgs']]] image_tag_mutability_exclusion_filters: Defines the image tag mutability exclusion filters to apply when creating repositories from this template. These filters specify which image tags can override the repository's default image tag mutability setting.
+        :param pulumi.Input[Sequence[pulumi.Input['RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgs']]] image_tag_mutability_exclusion_filters: A list of filters that specify which image tags are excluded from the repository creation template's image tag mutability setting.
         :param pulumi.Input[_builtins.str] lifecycle_policy: The lifecycle policy to use for repositories created using the template.
         :param pulumi.Input[_builtins.str] repository_policy: The repository policy to apply to repositories created using the template. A repository policy is a permissions policy associated with a repository to control access permissions.
         :param pulumi.Input[Sequence[pulumi.Input['RepositoryCreationTemplateTagArgs']]] resource_tags: The metadata to apply to the repository to help you categorize and organize. Each tag consists of a key and an optional value, both of which you define. Tag keys can have a maximum character length of 128 characters, and tag values can have a maximum length of 256 characters.
@@ -140,7 +140,7 @@ class RepositoryCreationTemplateArgs:
     @pulumi.getter(name="imageTagMutabilityExclusionFilters")
     def image_tag_mutability_exclusion_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgs']]]]:
         """
-        Defines the image tag mutability exclusion filters to apply when creating repositories from this template. These filters specify which image tags can override the repository's default image tag mutability setting.
+        A list of filters that specify which image tags are excluded from the repository creation template's image tag mutability setting.
         """
         return pulumi.get(self, "image_tag_mutability_exclusion_filters")
 
@@ -212,7 +212,7 @@ class RepositoryCreationTemplate(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] description: The description associated with the repository creation template.
         :param pulumi.Input[Union['RepositoryCreationTemplateEncryptionConfigurationArgs', 'RepositoryCreationTemplateEncryptionConfigurationArgsDict']] encryption_configuration: The encryption configuration associated with the repository creation template.
         :param pulumi.Input['RepositoryCreationTemplateImageTagMutability'] image_tag_mutability: The tag mutability setting for the repository. If this parameter is omitted, the default setting of ``MUTABLE`` will be used which will allow image tags to be overwritten. If ``IMMUTABLE`` is specified, all image tags within the repository will be immutable which will prevent them from being overwritten.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgs', 'RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgsDict']]]] image_tag_mutability_exclusion_filters: Defines the image tag mutability exclusion filters to apply when creating repositories from this template. These filters specify which image tags can override the repository's default image tag mutability setting.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgs', 'RepositoryCreationTemplateImageTagMutabilityExclusionFilterArgsDict']]]] image_tag_mutability_exclusion_filters: A list of filters that specify which image tags are excluded from the repository creation template's image tag mutability setting.
         :param pulumi.Input[_builtins.str] lifecycle_policy: The lifecycle policy to use for repositories created using the template.
         :param pulumi.Input[_builtins.str] prefix: The repository namespace prefix associated with the repository creation template.
         :param pulumi.Input[_builtins.str] repository_policy: The repository policy to apply to repositories created using the template. A repository policy is a permissions policy associated with a repository to control access permissions.
@@ -367,7 +367,7 @@ class RepositoryCreationTemplate(pulumi.CustomResource):
     @pulumi.getter(name="imageTagMutabilityExclusionFilters")
     def image_tag_mutability_exclusion_filters(self) -> pulumi.Output[Optional[Sequence['outputs.RepositoryCreationTemplateImageTagMutabilityExclusionFilter']]]:
         """
-        Defines the image tag mutability exclusion filters to apply when creating repositories from this template. These filters specify which image tags can override the repository's default image tag mutability setting.
+        A list of filters that specify which image tags are excluded from the repository creation template's image tag mutability setting.
         """
         return pulumi.get(self, "image_tag_mutability_exclusion_filters")
 

pulumi_aws_native/ecs/_inputs.py

@@ -5541,7 +5541,7 @@ if not MYPY:
         """
         cpu: NotRequired[pulumi.Input[_builtins.int]]
         """
-        The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create commandand the ``--cpu-shares`` option to docker run.
+        The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create command and the ``--cpu-shares`` option to docker run.
          This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level ``cpu`` value.
           You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
           Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
@@ -5835,7 +5835,7 @@ class TaskDefinitionContainerDefinitionArgs:
                  +  Images in other online repositories are qualified further by a domain name (for example, ``quay.io/assemblyline/ubuntu``).
         :param pulumi.Input[_builtins.str] name: The name of a container. If you're linking multiple containers together in a task definition, the ``name`` of one container can be entered in the ``links`` of another container to connect the containers. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. This parameter maps to ``name`` in the docker container create command and the ``--name`` option to docker run.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] command: The command that's passed to the container. This parameter maps to ``Cmd`` in the docker container create command and the ``COMMAND`` parameter to docker run. If there are multiple arguments, each argument is a separated string in the array.
-        :param pulumi.Input[_builtins.int] cpu: The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create commandand the ``--cpu-shares`` option to docker run.
+        :param pulumi.Input[_builtins.int] cpu: The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create command and the ``--cpu-shares`` option to docker run.
                 This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level ``cpu`` value.
                  You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
                  Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
@@ -6085,7 +6085,7 @@ class TaskDefinitionContainerDefinitionArgs:
     @pulumi.getter
     def cpu(self) -> Optional[pulumi.Input[_builtins.int]]:
         """
-        The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create commandand the ``--cpu-shares`` option to docker run.
+        The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create command and the ``--cpu-shares`` option to docker run.
          This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level ``cpu`` value.
           You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
           Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
@@ -8702,7 +8702,7 @@ if not MYPY:
         cpu_architecture: NotRequired[pulumi.Input[_builtins.str]]
         """
         The CPU architecture.
-         You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
+         You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance, Amazon ECS Managed Instances, or Linux containers on Fargate.
         """
         operating_system_family: NotRequired[pulumi.Input[_builtins.str]]
         """
@@ -8720,7 +8720,7 @@ class TaskDefinitionRuntimePlatformArgs:
         Information about the platform for the Amazon ECS service or task.
          For more information about ``RuntimePlatform``, see [RuntimePlatform](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#runtime-platform) in the *Amazon Elastic Container Service Developer Guide*.
         :param pulumi.Input[_builtins.str] cpu_architecture: The CPU architecture.
-                You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
+                You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance, Amazon ECS Managed Instances, or Linux containers on Fargate.
         :param pulumi.Input[_builtins.str] operating_system_family: The operating system.
         """
         if cpu_architecture is not None:
@@ -8733,7 +8733,7 @@ class TaskDefinitionRuntimePlatformArgs:
     def cpu_architecture(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
         The CPU architecture.
-         You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
+         You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance, Amazon ECS Managed Instances, or Linux containers on Fargate.
         """
         return pulumi.get(self, "cpu_architecture")
 

pulumi_aws_native/ecs/outputs.py

@@ -4373,7 +4373,7 @@ class TaskDefinitionContainerDefinition(dict):
                  +  Images in other online repositories are qualified further by a domain name (for example, ``quay.io/assemblyline/ubuntu``).
         :param _builtins.str name: The name of a container. If you're linking multiple containers together in a task definition, the ``name`` of one container can be entered in the ``links`` of another container to connect the containers. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. This parameter maps to ``name`` in the docker container create command and the ``--name`` option to docker run.
         :param Sequence[_builtins.str] command: The command that's passed to the container. This parameter maps to ``Cmd`` in the docker container create command and the ``COMMAND`` parameter to docker run. If there are multiple arguments, each argument is a separated string in the array.
-        :param _builtins.int cpu: The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create commandand the ``--cpu-shares`` option to docker run.
+        :param _builtins.int cpu: The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create command and the ``--cpu-shares`` option to docker run.
                 This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level ``cpu`` value.
                  You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
                  Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
@@ -4611,7 +4611,7 @@ class TaskDefinitionContainerDefinition(dict):
     @pulumi.getter
     def cpu(self) -> Optional[_builtins.int]:
         """
-        The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create commandand the ``--cpu-shares`` option to docker run.
+        The number of ``cpu`` units reserved for the container. This parameter maps to ``CpuShares`` in the docker container create command and the ``--cpu-shares`` option to docker run.
          This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level ``cpu`` value.
           You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
           Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
@@ -6684,7 +6684,7 @@ class TaskDefinitionRuntimePlatform(dict):
         Information about the platform for the Amazon ECS service or task.
          For more information about ``RuntimePlatform``, see [RuntimePlatform](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#runtime-platform) in the *Amazon Elastic Container Service Developer Guide*.
         :param _builtins.str cpu_architecture: The CPU architecture.
-                You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
+                You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance, Amazon ECS Managed Instances, or Linux containers on Fargate.
         :param _builtins.str operating_system_family: The operating system.
         """
         if cpu_architecture is not None:
@@ -6697,7 +6697,7 @@ class TaskDefinitionRuntimePlatform(dict):
     def cpu_architecture(self) -> Optional[_builtins.str]:
         """
         The CPU architecture.
-         You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
+         You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance, Amazon ECS Managed Instances, or Linux containers on Fargate.
         """
         return pulumi.get(self, "cpu_architecture")
 

pulumi_aws_native/ecs/task_definition.py

@@ -82,7 +82,7 @@ class TaskDefinitionArgs:
         :param pulumi.Input[_builtins.str] pid_mode: The process namespace to use for the containers in the task. The valid values are ``host`` or ``task``. On Fargate for Linux containers, the only valid value is ``task``. For example, monitoring sidecars might need ``pidMode`` to access information about other containers running in the same task.
                 If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance.
                 If ``task`` is specified, all containers within the specified task share the same process namespace.
-                If no value is specified, the default is a private namespace for each container.
+                If no value is specified, the The default is a private namespace for each container.
                 If the ``host`` PID mode is used, there's a heightened risk of undesired process namespace exposure.
                  This parameter is not supported for Windows containers.
                   This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.
@@ -91,7 +91,7 @@ class TaskDefinitionArgs:
         :param pulumi.Input['TaskDefinitionProxyConfigurationArgs'] proxy_configuration: The configuration details for the App Mesh proxy.
                 Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``MANAGED_INSTANCES``, ``EC2``, ``FARGATE``, and ``EXTERNAL``. 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*.
-        :param pulumi.Input['TaskDefinitionRuntimePlatformArgs'] runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
+        :param pulumi.Input['TaskDefinitionRuntimePlatformArgs'] runtime_platform: The operating system that your tasks definitions run on.
         :param pulumi.Input[Sequence[pulumi.Input['_root_inputs.TagArgs']]] tags: The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them.
                 The following basic restrictions apply to tags:
                  +  Maximum number of tags per resource - 50
@@ -294,7 +294,7 @@ class TaskDefinitionArgs:
         The process namespace to use for the containers in the task. The valid values are ``host`` or ``task``. On Fargate for Linux containers, the only valid value is ``task``. For example, monitoring sidecars might need ``pidMode`` to access information about other containers running in the same task.
          If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance.
          If ``task`` is specified, all containers within the specified task share the same process namespace.
-         If no value is specified, the default is a private namespace for each container.
+         If no value is specified, the The default is a private namespace for each container.
          If the ``host`` PID mode is used, there's a heightened risk of undesired process namespace exposure.
           This parameter is not supported for Windows containers.
            This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.
@@ -347,7 +347,7 @@ class TaskDefinitionArgs:
     @pulumi.getter(name="runtimePlatform")
     def runtime_platform(self) -> Optional[pulumi.Input['TaskDefinitionRuntimePlatformArgs']]:
         """
-        The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
+        The operating system that your tasks definitions run on.
         """
         return pulumi.get(self, "runtime_platform")
 
@@ -649,7 +649,7 @@ class TaskDefinition(pulumi.CustomResource):
         :param pulumi.Input[_builtins.str] pid_mode: The process namespace to use for the containers in the task. The valid values are ``host`` or ``task``. On Fargate for Linux containers, the only valid value is ``task``. For example, monitoring sidecars might need ``pidMode`` to access information about other containers running in the same task.
                 If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance.
                 If ``task`` is specified, all containers within the specified task share the same process namespace.
-                If no value is specified, the default is a private namespace for each container.
+                If no value is specified, the The default is a private namespace for each container.
                 If the ``host`` PID mode is used, there's a heightened risk of undesired process namespace exposure.
                  This parameter is not supported for Windows containers.
                   This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.
@@ -658,7 +658,7 @@ class TaskDefinition(pulumi.CustomResource):
         :param pulumi.Input[Union['TaskDefinitionProxyConfigurationArgs', 'TaskDefinitionProxyConfigurationArgsDict']] proxy_configuration: The configuration details for the App Mesh proxy.
                 Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``MANAGED_INSTANCES``, ``EC2``, ``FARGATE``, and ``EXTERNAL``. 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*.
-        :param pulumi.Input[Union['TaskDefinitionRuntimePlatformArgs', 'TaskDefinitionRuntimePlatformArgsDict']] runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
+        :param pulumi.Input[Union['TaskDefinitionRuntimePlatformArgs', 'TaskDefinitionRuntimePlatformArgsDict']] runtime_platform: The operating system that your tasks definitions run on.
         :param pulumi.Input[Sequence[pulumi.Input[Union['_root_inputs.TagArgs', '_root_inputs.TagArgsDict']]]] tags: The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them.
                 The following basic restrictions apply to tags:
                  +  Maximum number of tags per resource - 50
@@ -1077,7 +1077,7 @@ class TaskDefinition(pulumi.CustomResource):
         The process namespace to use for the containers in the task. The valid values are ``host`` or ``task``. On Fargate for Linux containers, the only valid value is ``task``. For example, monitoring sidecars might need ``pidMode`` to access information about other containers running in the same task.
          If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance.
          If ``task`` is specified, all containers within the specified task share the same process namespace.
-         If no value is specified, the default is a private namespace for each container.
+         If no value is specified, the The default is a private namespace for each container.
          If the ``host`` PID mode is used, there's a heightened risk of undesired process namespace exposure.
           This parameter is not supported for Windows containers.
            This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.
@@ -1114,7 +1114,7 @@ class TaskDefinition(pulumi.CustomResource):
     @pulumi.getter(name="runtimePlatform")
     def runtime_platform(self) -> pulumi.Output[Optional['outputs.TaskDefinitionRuntimePlatform']]:
         """
-        The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
+        The operating system that your tasks definitions run on.
         """
         return pulumi.get(self, "runtime_platform")
 

pulumi_aws_native/elasticloadbalancingv2/_inputs.py

@@ -2523,8 +2523,17 @@ class ListenerRuleRewriteConfigObjectArgs:
 
 if not MYPY:
     class ListenerRuleRewriteConfigArgsDict(TypedDict):
+        """
+        Information about a rewrite transform. This transform matches a pattern and replaces it with the specified string.
+        """
         regex: pulumi.Input[_builtins.str]
+        """
+        The regular expression to match in the input string. The maximum length of the string is 1,024 characters.
+        """
         replace: pulumi.Input[_builtins.str]
+        """
+        The replacement string to use when rewriting the matched input. The maximum length of the string is 1,024 characters. You can specify capture groups in the regular expression (for example, $1 and $2).
+        """
 elif False:
     ListenerRuleRewriteConfigArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -2533,12 +2542,20 @@ class ListenerRuleRewriteConfigArgs:
     def __init__(__self__, *,
                  regex: pulumi.Input[_builtins.str],
                  replace: pulumi.Input[_builtins.str]):
+        """
+        Information about a rewrite transform. This transform matches a pattern and replaces it with the specified string.
+        :param pulumi.Input[_builtins.str] regex: The regular expression to match in the input string. The maximum length of the string is 1,024 characters.
+        :param pulumi.Input[_builtins.str] replace: The replacement string to use when rewriting the matched input. The maximum length of the string is 1,024 characters. You can specify capture groups in the regular expression (for example, $1 and $2).
+        """
         pulumi.set(__self__, "regex", regex)
         pulumi.set(__self__, "replace", replace)
 
     @_builtins.property
     @pulumi.getter
     def regex(self) -> pulumi.Input[_builtins.str]:
+        """
+        The regular expression to match in the input string. The maximum length of the string is 1,024 characters.
+        """
         return pulumi.get(self, "regex")
 
     @regex.setter
@@ -2548,6 +2565,9 @@ class ListenerRuleRewriteConfigArgs:
     @_builtins.property
     @pulumi.getter
     def replace(self) -> pulumi.Input[_builtins.str]:
+        """
+        The replacement string to use when rewriting the matched input. The maximum length of the string is 1,024 characters. You can specify capture groups in the regular expression (for example, $1 and $2).
+        """
         return pulumi.get(self, "replace")
 
     @replace.setter
@@ -2592,7 +2612,7 @@ if not MYPY:
         """
         regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
-        The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when `Field` is `http-header` , `host-header` , or `path-pattern` .
+        The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when ``Field`` is ``http-header``, ``host-header``, or ``path-pattern``.
         """
         source_ip_config: NotRequired[pulumi.Input['ListenerRuleSourceIpConfigArgsDict']]
         """
@@ -2643,7 +2663,7 @@ class ListenerRuleRuleConditionArgs:
         :param pulumi.Input['ListenerRuleHttpRequestMethodConfigArgs'] http_request_method_config: Information for an HTTP method condition. Specify only when ``Field`` is ``http-request-method``.
         :param pulumi.Input['ListenerRulePathPatternConfigArgs'] path_pattern_config: Information for a path pattern condition. Specify only when ``Field`` is ``path-pattern``.
         :param pulumi.Input['ListenerRuleQueryStringConfigArgs'] query_string_config: Information for a query string condition. Specify only when ``Field`` is ``query-string``.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regex_values: The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when `Field` is `http-header` , `host-header` , or `path-pattern` .
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] regex_values: The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when ``Field`` is ``http-header``, ``host-header``, or ``path-pattern``.
         :param pulumi.Input['ListenerRuleSourceIpConfigArgs'] source_ip_config: Information for a source IP condition. Specify only when ``Field`` is ``source-ip``.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: The condition value. Specify only when ``Field`` is ``host-header`` or ``path-pattern``. Alternatively, to specify multiple host names or multiple path patterns, use ``HostHeaderConfig`` or ``PathPatternConfig``.
                 If ``Field`` is ``host-header`` and you're not using ``HostHeaderConfig``, you can specify a single host name (for example, my.example.com). A host name is case insensitive, can be up to 128 characters in length, and can contain any of the following characters.
@@ -2760,7 +2780,7 @@ class ListenerRuleRuleConditionArgs:
     @pulumi.getter(name="regexValues")
     def regex_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when `Field` is `http-header` , `host-header` , or `path-pattern` .
+        The regular expressions to match against the condition field. The maximum length of each string is 128 characters. Specify only when ``Field`` is ``http-header``, ``host-header``, or ``path-pattern``.
         """
         return pulumi.get(self, "regex_values")