pulumi-aws 7.15.0__py3-none-any.whl → 7.16.0__py3-none-any.whl

pulumi_aws/directconnect/get_gateway.py

@@ -26,7 +26,7 @@ class GetGatewayResult:
     """
     A collection of values returned by getGateway.
     """
-    def __init__(__self__, amazon_side_asn=None, arn=None, id=None, name=None, owner_account_id=None):
+    def __init__(__self__, amazon_side_asn=None, arn=None, id=None, name=None, owner_account_id=None, tags=None):
         if amazon_side_asn and not isinstance(amazon_side_asn, str):
             raise TypeError("Expected argument 'amazon_side_asn' to be a str")
         pulumi.set(__self__, "amazon_side_asn", amazon_side_asn)
@@ -42,6 +42,9 @@ class GetGatewayResult:
         if owner_account_id and not isinstance(owner_account_id, str):
             raise TypeError("Expected argument 'owner_account_id' to be a str")
         pulumi.set(__self__, "owner_account_id", owner_account_id)
+        if tags and not isinstance(tags, dict):
+            raise TypeError("Expected argument 'tags' to be a dict")
+        pulumi.set(__self__, "tags", tags)
 
     @_builtins.property
     @pulumi.getter(name="amazonSideAsn")
@@ -80,6 +83,14 @@ class GetGatewayResult:
         """
         return pulumi.get(self, "owner_account_id")
 
+    @_builtins.property
+    @pulumi.getter
+    def tags(self) -> Mapping[str, _builtins.str]:
+        """
+        A map of tags assigned to the gateway.
+        """
+        return pulumi.get(self, "tags")
+
 
 class AwaitableGetGatewayResult(GetGatewayResult):
     # pylint: disable=using-constant-test
@@ -91,10 +102,12 @@ class AwaitableGetGatewayResult(GetGatewayResult):
             arn=self.arn,
             id=self.id,
             name=self.name,
-            owner_account_id=self.owner_account_id)
+            owner_account_id=self.owner_account_id,
+            tags=self.tags)
 
 
 def get_gateway(name: Optional[_builtins.str] = None,
+                tags: Optional[Mapping[str, _builtins.str]] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGatewayResult:
     """
     Retrieve information about a Direct Connect Gateway.
@@ -110,9 +123,11 @@ def get_gateway(name: Optional[_builtins.str] = None,
 
 
     :param _builtins.str name: Name of the gateway to retrieve.
+    :param Mapping[str, _builtins.str] tags: A map of tags assigned to the gateway.
     """
     __args__ = dict()
     __args__['name'] = name
+    __args__['tags'] = tags
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('aws:directconnect/getGateway:getGateway', __args__, opts=opts, typ=GetGatewayResult).value
 
@@ -121,8 +136,10 @@ def get_gateway(name: Optional[_builtins.str] = None,
         arn=pulumi.get(__ret__, 'arn'),
         id=pulumi.get(__ret__, 'id'),
         name=pulumi.get(__ret__, 'name'),
-        owner_account_id=pulumi.get(__ret__, 'owner_account_id'))
+        owner_account_id=pulumi.get(__ret__, 'owner_account_id'),
+        tags=pulumi.get(__ret__, 'tags'))
 def get_gateway_output(name: Optional[pulumi.Input[_builtins.str]] = None,
+                       tags: Optional[pulumi.Input[Optional[Mapping[str, _builtins.str]]]] = None,
                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetGatewayResult]:
     """
     Retrieve information about a Direct Connect Gateway.
@@ -138,9 +155,11 @@ def get_gateway_output(name: Optional[pulumi.Input[_builtins.str]] = None,
 
 
     :param _builtins.str name: Name of the gateway to retrieve.
+    :param Mapping[str, _builtins.str] tags: A map of tags assigned to the gateway.
     """
     __args__ = dict()
     __args__['name'] = name
+    __args__['tags'] = tags
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('aws:directconnect/getGateway:getGateway', __args__, opts=opts, typ=GetGatewayResult)
     return __ret__.apply(lambda __response__: GetGatewayResult(
@@ -148,4 +167,5 @@ def get_gateway_output(name: Optional[pulumi.Input[_builtins.str]] = None,
         arn=pulumi.get(__response__, 'arn'),
         id=pulumi.get(__response__, 'id'),
         name=pulumi.get(__response__, 'name'),
-        owner_account_id=pulumi.get(__response__, 'owner_account_id')))
+        owner_account_id=pulumi.get(__response__, 'owner_account_id'),
+        tags=pulumi.get(__response__, 'tags')))

pulumi_aws/dlm/_inputs.py

@@ -1088,7 +1088,7 @@ if not MYPY:
     class LifecyclePolicyPolicyDetailsScheduleCreateRuleArgsDict(TypedDict):
         cron_expression: NotRequired[pulumi.Input[_builtins.str]]
         """
-        The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`.
+        The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`. For details on valid Cron expressions, see [here](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-cron-expressions).
         """
         interval: NotRequired[pulumi.Input[_builtins.int]]
         interval_unit: NotRequired[pulumi.Input[_builtins.str]]
@@ -1117,7 +1117,7 @@ class LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs:
                  scripts: Optional[pulumi.Input['LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs']] = None,
                  times: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.str] cron_expression: The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`.
+        :param pulumi.Input[_builtins.str] cron_expression: The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`. For details on valid Cron expressions, see [here](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-cron-expressions).
         :param pulumi.Input[_builtins.str] location: Specifies the destination for snapshots created by the policy. To create snapshots in the same Region as the source resource, specify `CLOUD`. To create snapshots on the same Outpost as the source resource, specify `OUTPOST_LOCAL`. If you omit this parameter, `CLOUD` is used by default. If the policy targets resources in an AWS Region, then you must create snapshots in the same Region as the source resource. If the policy targets resources on an Outpost, then you can create snapshots on the same Outpost as the source resource, or in the Region of that Outpost. Valid values are `CLOUD` and `OUTPOST_LOCAL`.
         :param pulumi.Input['LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs'] scripts: Specifies pre and/or post scripts for a snapshot lifecycle policy that targets instances. Valid only when `resource_type` is INSTANCE. See the `scripts` configuration block.
         :param pulumi.Input[_builtins.str] times: A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1. Conflicts with `cron_expression`. Must be set if `interval` is set.
@@ -1139,7 +1139,7 @@ class LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs:
     @pulumi.getter(name="cronExpression")
     def cron_expression(self) -> Optional[pulumi.Input[_builtins.str]]:
         """
-        The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`.
+        The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`. For details on valid Cron expressions, see [here](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-cron-expressions).
         """
         return pulumi.get(self, "cron_expression")
 

pulumi_aws/dlm/outputs.py

@@ -928,7 +928,7 @@ class LifecyclePolicyPolicyDetailsScheduleCreateRule(dict):
                  scripts: Optional['outputs.LifecyclePolicyPolicyDetailsScheduleCreateRuleScripts'] = None,
                  times: Optional[_builtins.str] = None):
         """
-        :param _builtins.str cron_expression: The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`.
+        :param _builtins.str cron_expression: The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`. For details on valid Cron expressions, see [here](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-cron-expressions).
         :param _builtins.str location: Specifies the destination for snapshots created by the policy. To create snapshots in the same Region as the source resource, specify `CLOUD`. To create snapshots on the same Outpost as the source resource, specify `OUTPOST_LOCAL`. If you omit this parameter, `CLOUD` is used by default. If the policy targets resources in an AWS Region, then you must create snapshots in the same Region as the source resource. If the policy targets resources on an Outpost, then you can create snapshots on the same Outpost as the source resource, or in the Region of that Outpost. Valid values are `CLOUD` and `OUTPOST_LOCAL`.
         :param 'LifecyclePolicyPolicyDetailsScheduleCreateRuleScriptsArgs' scripts: Specifies pre and/or post scripts for a snapshot lifecycle policy that targets instances. Valid only when `resource_type` is INSTANCE. See the `scripts` configuration block.
         :param _builtins.str times: A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1. Conflicts with `cron_expression`. Must be set if `interval` is set.
@@ -950,7 +950,7 @@ class LifecyclePolicyPolicyDetailsScheduleCreateRule(dict):
     @pulumi.getter(name="cronExpression")
     def cron_expression(self) -> Optional[_builtins.str]:
         """
-        The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`.
+        The schedule, as a Cron expression. The schedule interval must be between 1 hour and 1 year. Conflicts with `interval`, `interval_unit`, and `times`. For details on valid Cron expressions, see [here](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-scheduled-rule-pattern.html#eb-cron-expressions).
         """
         return pulumi.get(self, "cron_expression")
 

pulumi_aws/dynamodb/__init__.py

@@ -10,6 +10,7 @@ from .contributor_insights import *
 from .get_table import *
 from .get_table_item import *
 from .get_tables import *
+from .global_secondary_index import *
 from .global_table import *
 from .kinesis_streaming_destination import *
 from .resource_policy import *

pulumi_aws/dynamodb/_inputs.py

@@ -15,6 +15,18 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'GlobalSecondaryIndexKeySchemaArgs',
+    'GlobalSecondaryIndexKeySchemaArgsDict',
+    'GlobalSecondaryIndexOnDemandThroughputArgs',
+    'GlobalSecondaryIndexOnDemandThroughputArgsDict',
+    'GlobalSecondaryIndexProjectionArgs',
+    'GlobalSecondaryIndexProjectionArgsDict',
+    'GlobalSecondaryIndexProvisionedThroughputArgs',
+    'GlobalSecondaryIndexProvisionedThroughputArgsDict',
+    'GlobalSecondaryIndexTimeoutsArgs',
+    'GlobalSecondaryIndexTimeoutsArgsDict',
+    'GlobalSecondaryIndexWarmThroughputArgs',
+    'GlobalSecondaryIndexWarmThroughputArgsDict',
     'GlobalTableReplicaArgs',
     'GlobalTableReplicaArgsDict',
     'TableAttributeArgs',
@@ -57,6 +69,364 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class GlobalSecondaryIndexKeySchemaArgsDict(TypedDict):
+        attribute_name: pulumi.Input[_builtins.str]
+        """
+        Name of the attribute.
+        """
+        attribute_type: pulumi.Input[_builtins.str]
+        """
+        Type of the attribute in the index.
+        Valid values are `S` (string), `N` (number), or `B` (binary).
+        """
+        key_type: pulumi.Input[_builtins.str]
+        """
+        Key type.
+        Valid values are `HASH` or `RANGE`.
+        """
+elif False:
+    GlobalSecondaryIndexKeySchemaArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GlobalSecondaryIndexKeySchemaArgs:
+    def __init__(__self__, *,
+                 attribute_name: pulumi.Input[_builtins.str],
+                 attribute_type: pulumi.Input[_builtins.str],
+                 key_type: pulumi.Input[_builtins.str]):
+        """
+        :param pulumi.Input[_builtins.str] attribute_name: Name of the attribute.
+        :param pulumi.Input[_builtins.str] attribute_type: Type of the attribute in the index.
+               Valid values are `S` (string), `N` (number), or `B` (binary).
+        :param pulumi.Input[_builtins.str] key_type: Key type.
+               Valid values are `HASH` or `RANGE`.
+        """
+        pulumi.set(__self__, "attribute_name", attribute_name)
+        pulumi.set(__self__, "attribute_type", attribute_type)
+        pulumi.set(__self__, "key_type", key_type)
+
+    @_builtins.property
+    @pulumi.getter(name="attributeName")
+    def attribute_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        Name of the attribute.
+        """
+        return pulumi.get(self, "attribute_name")
+
+    @attribute_name.setter
+    def attribute_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "attribute_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="attributeType")
+    def attribute_type(self) -> pulumi.Input[_builtins.str]:
+        """
+        Type of the attribute in the index.
+        Valid values are `S` (string), `N` (number), or `B` (binary).
+        """
+        return pulumi.get(self, "attribute_type")
+
+    @attribute_type.setter
+    def attribute_type(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "attribute_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="keyType")
+    def key_type(self) -> pulumi.Input[_builtins.str]:
+        """
+        Key type.
+        Valid values are `HASH` or `RANGE`.
+        """
+        return pulumi.get(self, "key_type")
+
+    @key_type.setter
+    def key_type(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "key_type", value)
+
+
+if not MYPY:
+    class GlobalSecondaryIndexOnDemandThroughputArgsDict(TypedDict):
+        max_read_request_units: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Maximum number of read request units for this index.
+        """
+        max_write_request_units: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Maximum number of write request units for this index.
+        """
+elif False:
+    GlobalSecondaryIndexOnDemandThroughputArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GlobalSecondaryIndexOnDemandThroughputArgs:
+    def __init__(__self__, *,
+                 max_read_request_units: Optional[pulumi.Input[_builtins.int]] = None,
+                 max_write_request_units: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] max_read_request_units: Maximum number of read request units for this index.
+        :param pulumi.Input[_builtins.int] max_write_request_units: Maximum number of write request units for this index.
+        """
+        if max_read_request_units is not None:
+            pulumi.set(__self__, "max_read_request_units", max_read_request_units)
+        if max_write_request_units is not None:
+            pulumi.set(__self__, "max_write_request_units", max_write_request_units)
+
+    @_builtins.property
+    @pulumi.getter(name="maxReadRequestUnits")
+    def max_read_request_units(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Maximum number of read request units for this index.
+        """
+        return pulumi.get(self, "max_read_request_units")
+
+    @max_read_request_units.setter
+    def max_read_request_units(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_read_request_units", value)
+
+    @_builtins.property
+    @pulumi.getter(name="maxWriteRequestUnits")
+    def max_write_request_units(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Maximum number of write request units for this index.
+        """
+        return pulumi.get(self, "max_write_request_units")
+
+    @max_write_request_units.setter
+    def max_write_request_units(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_write_request_units", value)
+
+
+if not MYPY:
+    class GlobalSecondaryIndexProjectionArgsDict(TypedDict):
+        projection_type: pulumi.Input[_builtins.str]
+        """
+        The set of attributes represented in the index.
+        One of `ALL`, `INCLUDE`, or `KEYS_ONLY`.
+        """
+        non_key_attributes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
+        """
+        Specifies which additional attributes to include in the index.
+        Only valid when `projection_type` is `INCLUDE`.`
+        """
+elif False:
+    GlobalSecondaryIndexProjectionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GlobalSecondaryIndexProjectionArgs:
+    def __init__(__self__, *,
+                 projection_type: pulumi.Input[_builtins.str],
+                 non_key_attributes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
+        """
+        :param pulumi.Input[_builtins.str] projection_type: The set of attributes represented in the index.
+               One of `ALL`, `INCLUDE`, or `KEYS_ONLY`.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] non_key_attributes: Specifies which additional attributes to include in the index.
+               Only valid when `projection_type` is `INCLUDE`.`
+        """
+        pulumi.set(__self__, "projection_type", projection_type)
+        if non_key_attributes is not None:
+            pulumi.set(__self__, "non_key_attributes", non_key_attributes)
+
+    @_builtins.property
+    @pulumi.getter(name="projectionType")
+    def projection_type(self) -> pulumi.Input[_builtins.str]:
+        """
+        The set of attributes represented in the index.
+        One of `ALL`, `INCLUDE`, or `KEYS_ONLY`.
+        """
+        return pulumi.get(self, "projection_type")
+
+    @projection_type.setter
+    def projection_type(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "projection_type", value)
+
+    @_builtins.property
+    @pulumi.getter(name="nonKeyAttributes")
+    def non_key_attributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
+        """
+        Specifies which additional attributes to include in the index.
+        Only valid when `projection_type` is `INCLUDE`.`
+        """
+        return pulumi.get(self, "non_key_attributes")
+
+    @non_key_attributes.setter
+    def non_key_attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
+        pulumi.set(self, "non_key_attributes", value)
+
+
+if not MYPY:
+    class GlobalSecondaryIndexProvisionedThroughputArgsDict(TypedDict):
+        read_capacity_units: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Number of read capacity units for this index.
+        """
+        write_capacity_units: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Number of write capacity units for this index.
+        """
+elif False:
+    GlobalSecondaryIndexProvisionedThroughputArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GlobalSecondaryIndexProvisionedThroughputArgs:
+    def __init__(__self__, *,
+                 read_capacity_units: Optional[pulumi.Input[_builtins.int]] = None,
+                 write_capacity_units: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] read_capacity_units: Number of read capacity units for this index.
+        :param pulumi.Input[_builtins.int] write_capacity_units: Number of write capacity units for this index.
+        """
+        if read_capacity_units is not None:
+            pulumi.set(__self__, "read_capacity_units", read_capacity_units)
+        if write_capacity_units is not None:
+            pulumi.set(__self__, "write_capacity_units", write_capacity_units)
+
+    @_builtins.property
+    @pulumi.getter(name="readCapacityUnits")
+    def read_capacity_units(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Number of read capacity units for this index.
+        """
+        return pulumi.get(self, "read_capacity_units")
+
+    @read_capacity_units.setter
+    def read_capacity_units(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "read_capacity_units", value)
+
+    @_builtins.property
+    @pulumi.getter(name="writeCapacityUnits")
+    def write_capacity_units(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Number of write capacity units for this index.
+        """
+        return pulumi.get(self, "write_capacity_units")
+
+    @write_capacity_units.setter
+    def write_capacity_units(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "write_capacity_units", value)
+
+
+if not MYPY:
+    class GlobalSecondaryIndexTimeoutsArgsDict(TypedDict):
+        create: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        delete: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        """
+        update: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+elif False:
+    GlobalSecondaryIndexTimeoutsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GlobalSecondaryIndexTimeoutsArgs:
+    def __init__(__self__, *,
+                 create: Optional[pulumi.Input[_builtins.str]] = None,
+                 delete: Optional[pulumi.Input[_builtins.str]] = None,
+                 update: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] create: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        :param pulumi.Input[_builtins.str] delete: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        :param pulumi.Input[_builtins.str] update: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if delete is not None:
+            pulumi.set(__self__, "delete", delete)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @_builtins.property
+    @pulumi.getter
+    def create(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "create")
+
+    @create.setter
+    def create(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "create", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def delete(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        """
+        return pulumi.get(self, "delete")
+
+    @delete.setter
+    def delete(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "delete", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def update(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "update")
+
+    @update.setter
+    def update(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "update", value)
+
+
+if not MYPY:
+    class GlobalSecondaryIndexWarmThroughputArgsDict(TypedDict):
+        read_units_per_second: pulumi.Input[_builtins.int]
+        """
+        Number of read operations this index can instantaneously support.
+        """
+        write_units_per_second: pulumi.Input[_builtins.int]
+        """
+        Number of write operations this index can instantaneously support.
+        """
+elif False:
+    GlobalSecondaryIndexWarmThroughputArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GlobalSecondaryIndexWarmThroughputArgs:
+    def __init__(__self__, *,
+                 read_units_per_second: pulumi.Input[_builtins.int],
+                 write_units_per_second: pulumi.Input[_builtins.int]):
+        """
+        :param pulumi.Input[_builtins.int] read_units_per_second: Number of read operations this index can instantaneously support.
+        :param pulumi.Input[_builtins.int] write_units_per_second: Number of write operations this index can instantaneously support.
+        """
+        pulumi.set(__self__, "read_units_per_second", read_units_per_second)
+        pulumi.set(__self__, "write_units_per_second", write_units_per_second)
+
+    @_builtins.property
+    @pulumi.getter(name="readUnitsPerSecond")
+    def read_units_per_second(self) -> pulumi.Input[_builtins.int]:
+        """
+        Number of read operations this index can instantaneously support.
+        """
+        return pulumi.get(self, "read_units_per_second")
+
+    @read_units_per_second.setter
+    def read_units_per_second(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "read_units_per_second", value)
+
+    @_builtins.property
+    @pulumi.getter(name="writeUnitsPerSecond")
+    def write_units_per_second(self) -> pulumi.Input[_builtins.int]:
+        """
+        Number of write operations this index can instantaneously support.
+        """
+        return pulumi.get(self, "write_units_per_second")
+
+    @write_units_per_second.setter
+    def write_units_per_second(self, value: pulumi.Input[_builtins.int]):
+        pulumi.set(self, "write_units_per_second", value)
+
+
 if not MYPY:
     class GlobalTableReplicaArgsDict(TypedDict):
         region_name: pulumi.Input[_builtins.str]