aws-cdk-lib 2.125.0__py3-none-any.whl → 2.127.0__py3-none-any.whl

aws_cdk/aws_cassandra/__init__.py

@@ -215,7 +215,7 @@ class CfnKeyspace(
             region_list: typing.Optional[typing.Sequence[builtins.str]] = None,
             replication_strategy: typing.Optional[builtins.str] = None,
         ) -> None:
-            '''You can use ``ReplicationSpecification`` to configure the ``ReplicationStrategy`` of a keyspace in Amazon Keyspaces.
+            '''You can use ``ReplicationSpecification`` to configure the ``ReplicationStrategy`` of a keyspace in Amazon Keyspaces .
 
             The ``ReplicationSpecification`` property is ``CreateOnly`` and cannot be changed after the keyspace has been created. This property applies automatically to all tables in the keyspace.
 
@@ -424,6 +424,38 @@ class CfnTable(
             )],
         
             # the properties below are optional
+            auto_scaling_specifications=cassandra.CfnTable.AutoScalingSpecificationProperty(
+                read_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                    auto_scaling_disabled=False,
+                    maximum_units=123,
+                    minimum_units=123,
+                    scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                        target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                            target_value=123,
+        
+                            # the properties below are optional
+                            disable_scale_in=False,
+                            scale_in_cooldown=123,
+                            scale_out_cooldown=123
+                        )
+                    )
+                ),
+                write_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                    auto_scaling_disabled=False,
+                    maximum_units=123,
+                    minimum_units=123,
+                    scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                        target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                            target_value=123,
+        
+                            # the properties below are optional
+                            disable_scale_in=False,
+                            scale_in_cooldown=123,
+                            scale_out_cooldown=123
+                        )
+                    )
+                )
+            ),
             billing_mode=cassandra.CfnTable.BillingModeProperty(
                 mode="mode",
         
@@ -455,6 +487,27 @@ class CfnTable(
                 column_name="columnName",
                 column_type="columnType"
             )],
+            replica_specifications=[cassandra.CfnTable.ReplicaSpecificationProperty(
+                region="region",
+        
+                # the properties below are optional
+                read_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                    auto_scaling_disabled=False,
+                    maximum_units=123,
+                    minimum_units=123,
+                    scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                        target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                            target_value=123,
+        
+                            # the properties below are optional
+                            disable_scale_in=False,
+                            scale_in_cooldown=123,
+                            scale_out_cooldown=123
+                        )
+                    )
+                ),
+                read_capacity_units=123
+            )],
             table_name="tableName",
             tags=[CfnTag(
                 key="key",
@@ -470,6 +523,7 @@ class CfnTable(
         *,
         keyspace_name: builtins.str,
         partition_key_columns: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.ColumnProperty", typing.Dict[builtins.str, typing.Any]]]]],
+        auto_scaling_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.AutoScalingSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         billing_mode: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.BillingModeProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         clustering_key_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.ClusteringKeyColumnProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -477,6 +531,7 @@ class CfnTable(
         encryption_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.EncryptionSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         point_in_time_recovery_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         regular_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.ColumnProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        replica_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.ReplicaSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         table_name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
@@ -485,13 +540,15 @@ class CfnTable(
         :param id: Construct identifier for this resource (unique in its scope).
         :param keyspace_name: The name of the keyspace to create the table in. The keyspace must already exist.
         :param partition_key_columns: One or more columns that uniquely identify every row in the table. Every table must have a partition key.
+        :param auto_scaling_specifications: The optional auto scaling capacity settings for a table in provisioned capacity mode.
         :param billing_mode: The billing mode for the table, which determines how you'll be charged for reads and writes:. - *On-demand mode* (default) - You pay based on the actual reads and writes your application performs. - *Provisioned mode* - Lets you specify the number of reads and writes per second that you need for your application. If you don't specify a value for this property, then the table will use on-demand mode.
         :param client_side_timestamps_enabled: Enables client-side timestamps for the table. By default, the setting is disabled. You can enable client-side timestamps with the following option: - ``status: "enabled"`` After client-side timestamps are enabled for a table, you can't disable this setting.
         :param clustering_key_columns: One or more columns that determine how the table data is sorted.
         :param default_time_to_live: The default Time To Live (TTL) value for all rows in a table in seconds. The maximum configurable value is 630,720,000 seconds, which is the equivalent of 20 years. By default, the TTL value for a table is 0, which means data does not expire. For more information, see `Setting the default TTL value for a table <https://docs.aws.amazon.com/keyspaces/latest/devguide/TTL-how-it-works.html#ttl-howitworks_default_ttl>`_ in the *Amazon Keyspaces Developer Guide* .
-        :param encryption_specification: The encryption at rest options for the table. - *AWS owned key* (default) - The key is owned by Amazon Keyspaces. - *Customer managed key* - The key is stored in your account and is created, owned, and managed by you. .. epigraph:: If you choose encryption with a customer managed key, you must specify a valid customer managed KMS key with permissions granted to Amazon Keyspaces. For more information, see `Encryption at rest in Amazon Keyspaces <https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html>`_ in the *Amazon Keyspaces Developer Guide* .
+        :param encryption_specification: The encryption at rest options for the table. - *AWS owned key* (default) - The key is owned by Amazon Keyspaces . - *Customer managed key* - The key is stored in your account and is created, owned, and managed by you. .. epigraph:: If you choose encryption with a customer managed key, you must specify a valid customer managed KMS key with permissions granted to Amazon Keyspaces. For more information, see `Encryption at rest in Amazon Keyspaces <https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html>`_ in the *Amazon Keyspaces Developer Guide* .
         :param point_in_time_recovery_enabled: Specifies if point-in-time recovery is enabled or disabled for the table. The options are ``PointInTimeRecoveryEnabled=true`` and ``PointInTimeRecoveryEnabled=false`` . If not specified, the default is ``PointInTimeRecoveryEnabled=false`` .
         :param regular_columns: One or more columns that are not part of the primary key - that is, columns that are *not* defined as partition key columns or clustering key columns. You can add regular columns to existing tables by adding them to the template.
+        :param replica_specifications: The AWS Region specific settings of a multi-Region table. For a multi-Region table, you can configure the table's read capacity differently per AWS Region. You can do this by configuring the following parameters. - ``region`` : The Region where these settings are applied. (Required) - ``readCapacityUnits`` : The provisioned read capacity units. (Optional) - ``readCapacityAutoScaling`` : The read capacity auto scaling settings for the table. (Optional)
         :param table_name: The name of the table to be created. The table name is case sensitive. If you don't specify a name, AWS CloudFormation generates a unique ID and uses that ID for the table name. For more information, see `Name type <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html>`_ . .. epigraph:: If you specify a name, you can't perform updates that require replacing this resource. You can perform updates that require no interruption or some interruption. If you must replace the resource, specify a new name. *Length constraints:* Minimum length of 3. Maximum length of 255. *Pattern:* ``^[a-zA-Z0-9][a-zA-Z0-9_]{1,47}$``
         :param tags: An array of key-value pairs to apply to this resource. For more information, see `Tag <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html>`_ .
         '''
@@ -502,6 +559,7 @@ class CfnTable(
         props = CfnTableProps(
             keyspace_name=keyspace_name,
             partition_key_columns=partition_key_columns,
+            auto_scaling_specifications=auto_scaling_specifications,
             billing_mode=billing_mode,
             client_side_timestamps_enabled=client_side_timestamps_enabled,
             clustering_key_columns=clustering_key_columns,
@@ -509,6 +567,7 @@ class CfnTable(
             encryption_specification=encryption_specification,
             point_in_time_recovery_enabled=point_in_time_recovery_enabled,
             regular_columns=regular_columns,
+            replica_specifications=replica_specifications,
             table_name=table_name,
             tags=tags,
         )
@@ -587,6 +646,24 @@ class CfnTable(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "partitionKeyColumns", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="autoScalingSpecifications")
+    def auto_scaling_specifications(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSpecificationProperty"]]:
+        '''The optional auto scaling capacity settings for a table in provisioned capacity mode.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSpecificationProperty"]], jsii.get(self, "autoScalingSpecifications"))
+
+    @auto_scaling_specifications.setter
+    def auto_scaling_specifications(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSpecificationProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3195a4a3cd982603dec093989818a9b10de0aea3609d08a8cb43f320ba2a2228)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "autoScalingSpecifications", value)
+
     @builtins.property
     @jsii.member(jsii_name="billingMode")
     def billing_mode(
@@ -708,6 +785,24 @@ class CfnTable(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "regularColumns", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="replicaSpecifications")
+    def replica_specifications(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnTable.ReplicaSpecificationProperty"]]]]:
+        '''The AWS Region specific settings of a multi-Region table.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnTable.ReplicaSpecificationProperty"]]]], jsii.get(self, "replicaSpecifications"))
+
+    @replica_specifications.setter
+    def replica_specifications(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnTable.ReplicaSpecificationProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5733bf7940cc5b4e0c443c9b292d6c2f440a7bede5a0f631d4c1f894170bff53)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "replicaSpecifications", value)
+
     @builtins.property
     @jsii.member(jsii_name="tableName")
     def table_name(self) -> typing.Optional[builtins.str]:
@@ -734,6 +829,247 @@ class CfnTable(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "tagsRaw", value)
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_cassandra.CfnTable.AutoScalingSettingProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "auto_scaling_disabled": "autoScalingDisabled",
+            "maximum_units": "maximumUnits",
+            "minimum_units": "minimumUnits",
+            "scaling_policy": "scalingPolicy",
+        },
+    )
+    class AutoScalingSettingProperty:
+        def __init__(
+            self,
+            *,
+            auto_scaling_disabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            maximum_units: typing.Optional[jsii.Number] = None,
+            minimum_units: typing.Optional[jsii.Number] = None,
+            scaling_policy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.ScalingPolicyProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''The optional auto scaling settings for a table with provisioned throughput capacity.
+
+            To turn on auto scaling for a table in ``throughputMode:PROVISIONED`` , you must specify the following parameters.
+
+            Configure the minimum and maximum capacity units. The auto scaling policy ensures that capacity never goes below the minimum or above the maximum range.
+
+            - ``minimumUnits`` : The minimum level of throughput the table should always be ready to support. The value must be between 1 and the max throughput per second quota for your account (40,000 by default).
+            - ``maximumUnits`` : The maximum level of throughput the table should always be ready to support. The value must be between 1 and the max throughput per second quota for your account (40,000 by default).
+            - ``scalingPolicy`` : Amazon Keyspaces supports the ``target tracking`` scaling policy. The auto scaling target is a percentage of the provisioned capacity of the table.
+
+            For more information, see `Managing throughput capacity automatically with Amazon Keyspaces auto scaling <https://docs.aws.amazon.com/keyspaces/latest/devguide/autoscaling.html>`_ in the *Amazon Keyspaces Developer Guide* .
+
+            :param auto_scaling_disabled: This optional parameter enables auto scaling for the table if set to ``false`` . Default: - false
+            :param maximum_units: Manage costs by specifying the maximum amount of throughput to provision. The value must be between 1 and the max throughput per second quota for your account (40,000 by default).
+            :param minimum_units: The minimum level of throughput the table should always be ready to support. The value must be between 1 and the max throughput per second quota for your account (40,000 by default).
+            :param scaling_policy: Amazon Keyspaces supports the ``target tracking`` auto scaling policy. With this policy, Amazon Keyspaces auto scaling ensures that the table's ratio of consumed to provisioned capacity stays at or near the target value that you specify. You define the target value as a percentage between 20 and 90.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingsetting.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_cassandra as cassandra
+                
+                auto_scaling_setting_property = cassandra.CfnTable.AutoScalingSettingProperty(
+                    auto_scaling_disabled=False,
+                    maximum_units=123,
+                    minimum_units=123,
+                    scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                        target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                            target_value=123,
+                
+                            # the properties below are optional
+                            disable_scale_in=False,
+                            scale_in_cooldown=123,
+                            scale_out_cooldown=123
+                        )
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__2cb141a7c7ed6b1d9a39228641414ac62a7d79767996c73fe4911e45faa92ffd)
+                check_type(argname="argument auto_scaling_disabled", value=auto_scaling_disabled, expected_type=type_hints["auto_scaling_disabled"])
+                check_type(argname="argument maximum_units", value=maximum_units, expected_type=type_hints["maximum_units"])
+                check_type(argname="argument minimum_units", value=minimum_units, expected_type=type_hints["minimum_units"])
+                check_type(argname="argument scaling_policy", value=scaling_policy, expected_type=type_hints["scaling_policy"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if auto_scaling_disabled is not None:
+                self._values["auto_scaling_disabled"] = auto_scaling_disabled
+            if maximum_units is not None:
+                self._values["maximum_units"] = maximum_units
+            if minimum_units is not None:
+                self._values["minimum_units"] = minimum_units
+            if scaling_policy is not None:
+                self._values["scaling_policy"] = scaling_policy
+
+        @builtins.property
+        def auto_scaling_disabled(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''This optional parameter enables auto scaling for the table if set to ``false`` .
+
+            :default: - false
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingsetting.html#cfn-cassandra-table-autoscalingsetting-autoscalingdisabled
+            '''
+            result = self._values.get("auto_scaling_disabled")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
+        @builtins.property
+        def maximum_units(self) -> typing.Optional[jsii.Number]:
+            '''Manage costs by specifying the maximum amount of throughput to provision.
+
+            The value must be between 1 and the max throughput per second quota for your account (40,000 by default).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingsetting.html#cfn-cassandra-table-autoscalingsetting-maximumunits
+            '''
+            result = self._values.get("maximum_units")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def minimum_units(self) -> typing.Optional[jsii.Number]:
+            '''The minimum level of throughput the table should always be ready to support.
+
+            The value must be between 1 and the max throughput per second quota for your account (40,000 by default).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingsetting.html#cfn-cassandra-table-autoscalingsetting-minimumunits
+            '''
+            result = self._values.get("minimum_units")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def scaling_policy(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.ScalingPolicyProperty"]]:
+            '''Amazon Keyspaces supports the ``target tracking`` auto scaling policy.
+
+            With this policy, Amazon Keyspaces auto scaling ensures that the table's ratio of consumed to provisioned capacity stays at or near the target value that you specify. You define the target value as a percentage between 20 and 90.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingsetting.html#cfn-cassandra-table-autoscalingsetting-scalingpolicy
+            '''
+            result = self._values.get("scaling_policy")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.ScalingPolicyProperty"]], 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 "AutoScalingSettingProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_cassandra.CfnTable.AutoScalingSpecificationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "read_capacity_auto_scaling": "readCapacityAutoScaling",
+            "write_capacity_auto_scaling": "writeCapacityAutoScaling",
+        },
+    )
+    class AutoScalingSpecificationProperty:
+        def __init__(
+            self,
+            *,
+            read_capacity_auto_scaling: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.AutoScalingSettingProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            write_capacity_auto_scaling: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.AutoScalingSettingProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''The optional auto scaling capacity settings for a table in provisioned capacity mode.
+
+            :param read_capacity_auto_scaling: The auto scaling settings for the table's read capacity.
+            :param write_capacity_auto_scaling: The auto scaling settings for the table's write capacity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingspecification.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_cassandra as cassandra
+                
+                auto_scaling_specification_property = cassandra.CfnTable.AutoScalingSpecificationProperty(
+                    read_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                        auto_scaling_disabled=False,
+                        maximum_units=123,
+                        minimum_units=123,
+                        scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                            target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                                target_value=123,
+                
+                                # the properties below are optional
+                                disable_scale_in=False,
+                                scale_in_cooldown=123,
+                                scale_out_cooldown=123
+                            )
+                        )
+                    ),
+                    write_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                        auto_scaling_disabled=False,
+                        maximum_units=123,
+                        minimum_units=123,
+                        scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                            target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                                target_value=123,
+                
+                                # the properties below are optional
+                                disable_scale_in=False,
+                                scale_in_cooldown=123,
+                                scale_out_cooldown=123
+                            )
+                        )
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__47c7d8efc57f0cc9c23ff9d319e31aa9f85ff8366a45b688f508d822b11eadd4)
+                check_type(argname="argument read_capacity_auto_scaling", value=read_capacity_auto_scaling, expected_type=type_hints["read_capacity_auto_scaling"])
+                check_type(argname="argument write_capacity_auto_scaling", value=write_capacity_auto_scaling, expected_type=type_hints["write_capacity_auto_scaling"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if read_capacity_auto_scaling is not None:
+                self._values["read_capacity_auto_scaling"] = read_capacity_auto_scaling
+            if write_capacity_auto_scaling is not None:
+                self._values["write_capacity_auto_scaling"] = write_capacity_auto_scaling
+
+        @builtins.property
+        def read_capacity_auto_scaling(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSettingProperty"]]:
+            '''The auto scaling settings for the table's read capacity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingspecification.html#cfn-cassandra-table-autoscalingspecification-readcapacityautoscaling
+            '''
+            result = self._values.get("read_capacity_auto_scaling")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSettingProperty"]], result)
+
+        @builtins.property
+        def write_capacity_auto_scaling(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSettingProperty"]]:
+            '''The auto scaling settings for the table's write capacity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-autoscalingspecification.html#cfn-cassandra-table-autoscalingspecification-writecapacityautoscaling
+            '''
+            result = self._values.get("write_capacity_auto_scaling")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSettingProperty"]], 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 "AutoScalingSpecificationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_cassandra.CfnTable.BillingModeProperty",
         jsii_struct_bases=[],
@@ -925,6 +1261,11 @@ class CfnTable(
         ) -> None:
             '''The name and data type of an individual column in a table.
 
+            In addition to the data type, you can also use the following two keywords:
+
+            - ``STATIC`` if the table has a clustering column. Static columns store values that are shared by all rows in the same partition.
+            - ``FROZEN`` for collection data types. In frozen collections the values of the collection are serialized into a single immutable value, and Amazon Keyspaces treats them like a ``BLOB`` .
+
             :param column_name: The name of the column. For more information, see `Identifiers <https://docs.aws.amazon.com/keyspaces/latest/devguide/cql.elements.html#cql.elements.identifier>`_ in the *Amazon Keyspaces Developer Guide* .
             :param column_type: The data type of the column. For more information, see `Data types <https://docs.aws.amazon.com/keyspaces/latest/devguide/cql.elements.html#cql.data-types>`_ in the *Amazon Keyspaces Developer Guide* .
 
@@ -1151,6 +1492,318 @@ class CfnTable(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_cassandra.CfnTable.ReplicaSpecificationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "region": "region",
+            "read_capacity_auto_scaling": "readCapacityAutoScaling",
+            "read_capacity_units": "readCapacityUnits",
+        },
+    )
+    class ReplicaSpecificationProperty:
+        def __init__(
+            self,
+            *,
+            region: builtins.str,
+            read_capacity_auto_scaling: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.AutoScalingSettingProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            read_capacity_units: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The AWS Region specific settings of a multi-Region table.
+
+            For a multi-Region table, you can configure the table's read capacity differently per AWS Region. You can do this by configuring the following parameters.
+
+            - ``region`` : The Region where these settings are applied. (Required)
+            - ``readCapacityUnits`` : The provisioned read capacity units. (Optional)
+            - ``readCapacityAutoScaling`` : The read capacity auto scaling settings for the table. (Optional)
+
+            :param region: The AWS Region.
+            :param read_capacity_auto_scaling: The read capacity auto scaling settings for the multi-Region table in the specified AWS Region.
+            :param read_capacity_units: The provisioned read capacity units for the multi-Region table in the specified AWS Region.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-replicaspecification.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_cassandra as cassandra
+                
+                replica_specification_property = cassandra.CfnTable.ReplicaSpecificationProperty(
+                    region="region",
+                
+                    # the properties below are optional
+                    read_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                        auto_scaling_disabled=False,
+                        maximum_units=123,
+                        minimum_units=123,
+                        scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                            target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                                target_value=123,
+                
+                                # the properties below are optional
+                                disable_scale_in=False,
+                                scale_in_cooldown=123,
+                                scale_out_cooldown=123
+                            )
+                        )
+                    ),
+                    read_capacity_units=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__06993df19646af34c044f18b07ace5cd635a3e192224fc5b9277509c659097ac)
+                check_type(argname="argument region", value=region, expected_type=type_hints["region"])
+                check_type(argname="argument read_capacity_auto_scaling", value=read_capacity_auto_scaling, expected_type=type_hints["read_capacity_auto_scaling"])
+                check_type(argname="argument read_capacity_units", value=read_capacity_units, expected_type=type_hints["read_capacity_units"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "region": region,
+            }
+            if read_capacity_auto_scaling is not None:
+                self._values["read_capacity_auto_scaling"] = read_capacity_auto_scaling
+            if read_capacity_units is not None:
+                self._values["read_capacity_units"] = read_capacity_units
+
+        @builtins.property
+        def region(self) -> builtins.str:
+            '''The AWS Region.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-replicaspecification.html#cfn-cassandra-table-replicaspecification-region
+            '''
+            result = self._values.get("region")
+            assert result is not None, "Required property 'region' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def read_capacity_auto_scaling(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSettingProperty"]]:
+            '''The read capacity auto scaling settings for the multi-Region table in the specified AWS Region.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-replicaspecification.html#cfn-cassandra-table-replicaspecification-readcapacityautoscaling
+            '''
+            result = self._values.get("read_capacity_auto_scaling")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.AutoScalingSettingProperty"]], result)
+
+        @builtins.property
+        def read_capacity_units(self) -> typing.Optional[jsii.Number]:
+            '''The provisioned read capacity units for the multi-Region table in the specified AWS Region.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-replicaspecification.html#cfn-cassandra-table-replicaspecification-readcapacityunits
+            '''
+            result = self._values.get("read_capacity_units")
+            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 "ReplicaSpecificationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_cassandra.CfnTable.ScalingPolicyProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "target_tracking_scaling_policy_configuration": "targetTrackingScalingPolicyConfiguration",
+        },
+    )
+    class ScalingPolicyProperty:
+        def __init__(
+            self,
+            *,
+            target_tracking_scaling_policy_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.TargetTrackingScalingPolicyConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''Amazon Keyspaces supports the ``target tracking`` auto scaling policy.
+
+            With this policy, Amazon Keyspaces auto scaling ensures that the table's ratio of consumed to provisioned capacity stays at or near the target value that you specify. You define the target value as a percentage between 20 and 90.
+
+            :param target_tracking_scaling_policy_configuration: The auto scaling policy that scales a table based on the ratio of consumed to provisioned capacity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-scalingpolicy.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_cassandra as cassandra
+                
+                scaling_policy_property = cassandra.CfnTable.ScalingPolicyProperty(
+                    target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                        target_value=123,
+                
+                        # the properties below are optional
+                        disable_scale_in=False,
+                        scale_in_cooldown=123,
+                        scale_out_cooldown=123
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__67fdfae50d59915fee6d91803c13e24de12b1573e762d8de76bc0cbeaba9a2d8)
+                check_type(argname="argument target_tracking_scaling_policy_configuration", value=target_tracking_scaling_policy_configuration, expected_type=type_hints["target_tracking_scaling_policy_configuration"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if target_tracking_scaling_policy_configuration is not None:
+                self._values["target_tracking_scaling_policy_configuration"] = target_tracking_scaling_policy_configuration
+
+        @builtins.property
+        def target_tracking_scaling_policy_configuration(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.TargetTrackingScalingPolicyConfigurationProperty"]]:
+            '''The auto scaling policy that scales a table based on the ratio of consumed to provisioned capacity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-scalingpolicy.html#cfn-cassandra-table-scalingpolicy-targettrackingscalingpolicyconfiguration
+            '''
+            result = self._values.get("target_tracking_scaling_policy_configuration")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.TargetTrackingScalingPolicyConfigurationProperty"]], 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 "ScalingPolicyProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "target_value": "targetValue",
+            "disable_scale_in": "disableScaleIn",
+            "scale_in_cooldown": "scaleInCooldown",
+            "scale_out_cooldown": "scaleOutCooldown",
+        },
+    )
+    class TargetTrackingScalingPolicyConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            target_value: jsii.Number,
+            disable_scale_in: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            scale_in_cooldown: typing.Optional[jsii.Number] = None,
+            scale_out_cooldown: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''Amazon Keyspaces supports the ``target tracking`` auto scaling policy for a provisioned table.
+
+            This policy scales a table based on the ratio of consumed to provisioned capacity. The auto scaling target is a percentage of the provisioned capacity of the table.
+
+            - ``targetTrackingScalingPolicyConfiguration`` : To define the target tracking policy, you must define the target value.
+            - ``targetValue`` : The target utilization rate of the table. Amazon Keyspaces auto scaling ensures that the ratio of consumed capacity to provisioned capacity stays at or near this value. You define ``targetValue`` as a percentage. A ``double`` between 20 and 90. (Required)
+            - ``disableScaleIn`` : A ``boolean`` that specifies if ``scale-in`` is disabled or enabled for the table. This parameter is disabled by default. To turn on ``scale-in`` , set the ``boolean`` value to ``FALSE`` . This means that capacity for a table can be automatically scaled down on your behalf. (Optional)
+            - ``scaleInCooldown`` : A cooldown period in seconds between scaling activities that lets the table stabilize before another scale in activity starts. If no value is provided, the default is 0. (Optional)
+            - ``scaleOutCooldown`` : A cooldown period in seconds between scaling activities that lets the table stabilize before another scale out activity starts. If no value is provided, the default is 0. (Optional)
+
+            :param target_value: Specifies the target value for the target tracking auto scaling policy. Amazon Keyspaces auto scaling scales up capacity automatically when traffic exceeds this target utilization rate, and then back down when it falls below the target. This ensures that the ratio of consumed capacity to provisioned capacity stays at or near this value. You define ``targetValue`` as a percentage. An ``integer`` between 20 and 90.
+            :param disable_scale_in: Specifies if ``scale-in`` is enabled. When auto scaling automatically decreases capacity for a table, the table *scales in* . When scaling policies are set, they can't scale in the table lower than its minimum capacity.
+            :param scale_in_cooldown: Specifies a ``scale-in`` cool down period. A cooldown period in seconds between scaling activities that lets the table stabilize before another scaling activity starts. Default: - 0
+            :param scale_out_cooldown: Specifies a scale out cool down period. A cooldown period in seconds between scaling activities that lets the table stabilize before another scaling activity starts. Default: - 0
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-targettrackingscalingpolicyconfiguration.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_cassandra as cassandra
+                
+                target_tracking_scaling_policy_configuration_property = cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                    target_value=123,
+                
+                    # the properties below are optional
+                    disable_scale_in=False,
+                    scale_in_cooldown=123,
+                    scale_out_cooldown=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__23200b02c7e7d1fd9b0336257d7f6dd749b95e0adc13464370ca6af1b666da1c)
+                check_type(argname="argument target_value", value=target_value, expected_type=type_hints["target_value"])
+                check_type(argname="argument disable_scale_in", value=disable_scale_in, expected_type=type_hints["disable_scale_in"])
+                check_type(argname="argument scale_in_cooldown", value=scale_in_cooldown, expected_type=type_hints["scale_in_cooldown"])
+                check_type(argname="argument scale_out_cooldown", value=scale_out_cooldown, expected_type=type_hints["scale_out_cooldown"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "target_value": target_value,
+            }
+            if disable_scale_in is not None:
+                self._values["disable_scale_in"] = disable_scale_in
+            if scale_in_cooldown is not None:
+                self._values["scale_in_cooldown"] = scale_in_cooldown
+            if scale_out_cooldown is not None:
+                self._values["scale_out_cooldown"] = scale_out_cooldown
+
+        @builtins.property
+        def target_value(self) -> jsii.Number:
+            '''Specifies the target value for the target tracking auto scaling policy.
+
+            Amazon Keyspaces auto scaling scales up capacity automatically when traffic exceeds this target utilization rate, and then back down when it falls below the target. This ensures that the ratio of consumed capacity to provisioned capacity stays at or near this value. You define ``targetValue`` as a percentage. An ``integer`` between 20 and 90.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-targettrackingscalingpolicyconfiguration.html#cfn-cassandra-table-targettrackingscalingpolicyconfiguration-targetvalue
+            '''
+            result = self._values.get("target_value")
+            assert result is not None, "Required property 'target_value' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def disable_scale_in(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Specifies if ``scale-in`` is enabled.
+
+            When auto scaling automatically decreases capacity for a table, the table *scales in* . When scaling policies are set, they can't scale in the table lower than its minimum capacity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-targettrackingscalingpolicyconfiguration.html#cfn-cassandra-table-targettrackingscalingpolicyconfiguration-disablescalein
+            '''
+            result = self._values.get("disable_scale_in")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
+        @builtins.property
+        def scale_in_cooldown(self) -> typing.Optional[jsii.Number]:
+            '''Specifies a ``scale-in`` cool down period.
+
+            A cooldown period in seconds between scaling activities that lets the table stabilize before another scaling activity starts.
+
+            :default: - 0
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-targettrackingscalingpolicyconfiguration.html#cfn-cassandra-table-targettrackingscalingpolicyconfiguration-scaleincooldown
+            '''
+            result = self._values.get("scale_in_cooldown")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def scale_out_cooldown(self) -> typing.Optional[jsii.Number]:
+            '''Specifies a scale out cool down period.
+
+            A cooldown period in seconds between scaling activities that lets the table stabilize before another scaling activity starts.
+
+            :default: - 0
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-table-targettrackingscalingpolicyconfiguration.html#cfn-cassandra-table-targettrackingscalingpolicyconfiguration-scaleoutcooldown
+            '''
+            result = self._values.get("scale_out_cooldown")
+            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 "TargetTrackingScalingPolicyConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_cassandra.CfnTableProps",
@@ -1158,6 +1811,7 @@ class CfnTable(
     name_mapping={
         "keyspace_name": "keyspaceName",
         "partition_key_columns": "partitionKeyColumns",
+        "auto_scaling_specifications": "autoScalingSpecifications",
         "billing_mode": "billingMode",
         "client_side_timestamps_enabled": "clientSideTimestampsEnabled",
         "clustering_key_columns": "clusteringKeyColumns",
@@ -1165,6 +1819,7 @@ class CfnTable(
         "encryption_specification": "encryptionSpecification",
         "point_in_time_recovery_enabled": "pointInTimeRecoveryEnabled",
         "regular_columns": "regularColumns",
+        "replica_specifications": "replicaSpecifications",
         "table_name": "tableName",
         "tags": "tags",
     },
@@ -1175,6 +1830,7 @@ class CfnTableProps:
         *,
         keyspace_name: builtins.str,
         partition_key_columns: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ColumnProperty, typing.Dict[builtins.str, typing.Any]]]]],
+        auto_scaling_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.AutoScalingSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         billing_mode: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.BillingModeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         clustering_key_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ClusteringKeyColumnProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -1182,6 +1838,7 @@ class CfnTableProps:
         encryption_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.EncryptionSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         point_in_time_recovery_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         regular_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ColumnProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        replica_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ReplicaSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
         table_name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
@@ -1189,13 +1846,15 @@ class CfnTableProps:
 
         :param keyspace_name: The name of the keyspace to create the table in. The keyspace must already exist.
         :param partition_key_columns: One or more columns that uniquely identify every row in the table. Every table must have a partition key.
+        :param auto_scaling_specifications: The optional auto scaling capacity settings for a table in provisioned capacity mode.
         :param billing_mode: The billing mode for the table, which determines how you'll be charged for reads and writes:. - *On-demand mode* (default) - You pay based on the actual reads and writes your application performs. - *Provisioned mode* - Lets you specify the number of reads and writes per second that you need for your application. If you don't specify a value for this property, then the table will use on-demand mode.
         :param client_side_timestamps_enabled: Enables client-side timestamps for the table. By default, the setting is disabled. You can enable client-side timestamps with the following option: - ``status: "enabled"`` After client-side timestamps are enabled for a table, you can't disable this setting.
         :param clustering_key_columns: One or more columns that determine how the table data is sorted.
         :param default_time_to_live: The default Time To Live (TTL) value for all rows in a table in seconds. The maximum configurable value is 630,720,000 seconds, which is the equivalent of 20 years. By default, the TTL value for a table is 0, which means data does not expire. For more information, see `Setting the default TTL value for a table <https://docs.aws.amazon.com/keyspaces/latest/devguide/TTL-how-it-works.html#ttl-howitworks_default_ttl>`_ in the *Amazon Keyspaces Developer Guide* .
-        :param encryption_specification: The encryption at rest options for the table. - *AWS owned key* (default) - The key is owned by Amazon Keyspaces. - *Customer managed key* - The key is stored in your account and is created, owned, and managed by you. .. epigraph:: If you choose encryption with a customer managed key, you must specify a valid customer managed KMS key with permissions granted to Amazon Keyspaces. For more information, see `Encryption at rest in Amazon Keyspaces <https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html>`_ in the *Amazon Keyspaces Developer Guide* .
+        :param encryption_specification: The encryption at rest options for the table. - *AWS owned key* (default) - The key is owned by Amazon Keyspaces . - *Customer managed key* - The key is stored in your account and is created, owned, and managed by you. .. epigraph:: If you choose encryption with a customer managed key, you must specify a valid customer managed KMS key with permissions granted to Amazon Keyspaces. For more information, see `Encryption at rest in Amazon Keyspaces <https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html>`_ in the *Amazon Keyspaces Developer Guide* .
         :param point_in_time_recovery_enabled: Specifies if point-in-time recovery is enabled or disabled for the table. The options are ``PointInTimeRecoveryEnabled=true`` and ``PointInTimeRecoveryEnabled=false`` . If not specified, the default is ``PointInTimeRecoveryEnabled=false`` .
         :param regular_columns: One or more columns that are not part of the primary key - that is, columns that are *not* defined as partition key columns or clustering key columns. You can add regular columns to existing tables by adding them to the template.
+        :param replica_specifications: The AWS Region specific settings of a multi-Region table. For a multi-Region table, you can configure the table's read capacity differently per AWS Region. You can do this by configuring the following parameters. - ``region`` : The Region where these settings are applied. (Required) - ``readCapacityUnits`` : The provisioned read capacity units. (Optional) - ``readCapacityAutoScaling`` : The read capacity auto scaling settings for the table. (Optional)
         :param table_name: The name of the table to be created. The table name is case sensitive. If you don't specify a name, AWS CloudFormation generates a unique ID and uses that ID for the table name. For more information, see `Name type <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html>`_ . .. epigraph:: If you specify a name, you can't perform updates that require replacing this resource. You can perform updates that require no interruption or some interruption. If you must replace the resource, specify a new name. *Length constraints:* Minimum length of 3. Maximum length of 255. *Pattern:* ``^[a-zA-Z0-9][a-zA-Z0-9_]{1,47}$``
         :param tags: An array of key-value pairs to apply to this resource. For more information, see `Tag <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html>`_ .
 
@@ -1216,6 +1875,38 @@ class CfnTableProps:
                 )],
             
                 # the properties below are optional
+                auto_scaling_specifications=cassandra.CfnTable.AutoScalingSpecificationProperty(
+                    read_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                        auto_scaling_disabled=False,
+                        maximum_units=123,
+                        minimum_units=123,
+                        scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                            target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                                target_value=123,
+            
+                                # the properties below are optional
+                                disable_scale_in=False,
+                                scale_in_cooldown=123,
+                                scale_out_cooldown=123
+                            )
+                        )
+                    ),
+                    write_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                        auto_scaling_disabled=False,
+                        maximum_units=123,
+                        minimum_units=123,
+                        scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                            target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                                target_value=123,
+            
+                                # the properties below are optional
+                                disable_scale_in=False,
+                                scale_in_cooldown=123,
+                                scale_out_cooldown=123
+                            )
+                        )
+                    )
+                ),
                 billing_mode=cassandra.CfnTable.BillingModeProperty(
                     mode="mode",
             
@@ -1247,6 +1938,27 @@ class CfnTableProps:
                     column_name="columnName",
                     column_type="columnType"
                 )],
+                replica_specifications=[cassandra.CfnTable.ReplicaSpecificationProperty(
+                    region="region",
+            
+                    # the properties below are optional
+                    read_capacity_auto_scaling=cassandra.CfnTable.AutoScalingSettingProperty(
+                        auto_scaling_disabled=False,
+                        maximum_units=123,
+                        minimum_units=123,
+                        scaling_policy=cassandra.CfnTable.ScalingPolicyProperty(
+                            target_tracking_scaling_policy_configuration=cassandra.CfnTable.TargetTrackingScalingPolicyConfigurationProperty(
+                                target_value=123,
+            
+                                # the properties below are optional
+                                disable_scale_in=False,
+                                scale_in_cooldown=123,
+                                scale_out_cooldown=123
+                            )
+                        )
+                    ),
+                    read_capacity_units=123
+                )],
                 table_name="tableName",
                 tags=[CfnTag(
                     key="key",
@@ -1258,6 +1970,7 @@ class CfnTableProps:
             type_hints = typing.get_type_hints(_typecheckingstub__bd1ff29b1ec22382a7c3d14031657668106b0fcd843c06a96897bcadf10ffa92)
             check_type(argname="argument keyspace_name", value=keyspace_name, expected_type=type_hints["keyspace_name"])
             check_type(argname="argument partition_key_columns", value=partition_key_columns, expected_type=type_hints["partition_key_columns"])
+            check_type(argname="argument auto_scaling_specifications", value=auto_scaling_specifications, expected_type=type_hints["auto_scaling_specifications"])
             check_type(argname="argument billing_mode", value=billing_mode, expected_type=type_hints["billing_mode"])
             check_type(argname="argument client_side_timestamps_enabled", value=client_side_timestamps_enabled, expected_type=type_hints["client_side_timestamps_enabled"])
             check_type(argname="argument clustering_key_columns", value=clustering_key_columns, expected_type=type_hints["clustering_key_columns"])
@@ -1265,12 +1978,15 @@ class CfnTableProps:
             check_type(argname="argument encryption_specification", value=encryption_specification, expected_type=type_hints["encryption_specification"])
             check_type(argname="argument point_in_time_recovery_enabled", value=point_in_time_recovery_enabled, expected_type=type_hints["point_in_time_recovery_enabled"])
             check_type(argname="argument regular_columns", value=regular_columns, expected_type=type_hints["regular_columns"])
+            check_type(argname="argument replica_specifications", value=replica_specifications, expected_type=type_hints["replica_specifications"])
             check_type(argname="argument table_name", value=table_name, expected_type=type_hints["table_name"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "keyspace_name": keyspace_name,
             "partition_key_columns": partition_key_columns,
         }
+        if auto_scaling_specifications is not None:
+            self._values["auto_scaling_specifications"] = auto_scaling_specifications
         if billing_mode is not None:
             self._values["billing_mode"] = billing_mode
         if client_side_timestamps_enabled is not None:
@@ -1285,6 +2001,8 @@ class CfnTableProps:
             self._values["point_in_time_recovery_enabled"] = point_in_time_recovery_enabled
         if regular_columns is not None:
             self._values["regular_columns"] = regular_columns
+        if replica_specifications is not None:
+            self._values["replica_specifications"] = replica_specifications
         if table_name is not None:
             self._values["table_name"] = table_name
         if tags is not None:
@@ -1316,6 +2034,17 @@ class CfnTableProps:
         assert result is not None, "Required property 'partition_key_columns' is missing"
         return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTable.ColumnProperty]]], result)
 
+    @builtins.property
+    def auto_scaling_specifications(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.AutoScalingSpecificationProperty]]:
+        '''The optional auto scaling capacity settings for a table in provisioned capacity mode.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-table.html#cfn-cassandra-table-autoscalingspecifications
+        '''
+        result = self._values.get("auto_scaling_specifications")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.AutoScalingSpecificationProperty]], result)
+
     @builtins.property
     def billing_mode(
         self,
@@ -1379,7 +2108,7 @@ class CfnTableProps:
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.EncryptionSpecificationProperty]]:
         '''The encryption at rest options for the table.
 
-        - *AWS owned key* (default) - The key is owned by Amazon Keyspaces.
+        - *AWS owned key* (default) - The key is owned by Amazon Keyspaces .
         - *Customer managed key* - The key is stored in your account and is created, owned, and managed by you.
 
         .. epigraph::
@@ -1419,6 +2148,23 @@ class CfnTableProps:
         result = self._values.get("regular_columns")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTable.ColumnProperty]]]], result)
 
+    @builtins.property
+    def replica_specifications(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTable.ReplicaSpecificationProperty]]]]:
+        '''The AWS Region specific settings of a multi-Region table.
+
+        For a multi-Region table, you can configure the table's read capacity differently per AWS Region. You can do this by configuring the following parameters.
+
+        - ``region`` : The Region where these settings are applied. (Required)
+        - ``readCapacityUnits`` : The provisioned read capacity units. (Optional)
+        - ``readCapacityAutoScaling`` : The read capacity auto scaling settings for the table. (Optional)
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-table.html#cfn-cassandra-table-replicaspecifications
+        '''
+        result = self._values.get("replica_specifications")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTable.ReplicaSpecificationProperty]]]], result)
+
     @builtins.property
     def table_name(self) -> typing.Optional[builtins.str]:
         '''The name of the table to be created.
@@ -1533,6 +2279,7 @@ def _typecheckingstub__9d6fd025c7c0c8d4a27519b568ec6952b027c14ffb932a0cd5e53f0aa
     *,
     keyspace_name: builtins.str,
     partition_key_columns: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ColumnProperty, typing.Dict[builtins.str, typing.Any]]]]],
+    auto_scaling_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.AutoScalingSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     billing_mode: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.BillingModeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     clustering_key_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ClusteringKeyColumnProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -1540,6 +2287,7 @@ def _typecheckingstub__9d6fd025c7c0c8d4a27519b568ec6952b027c14ffb932a0cd5e53f0aa
     encryption_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.EncryptionSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     point_in_time_recovery_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     regular_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ColumnProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    replica_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ReplicaSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     table_name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
@@ -1570,6 +2318,12 @@ def _typecheckingstub__e1db183d8a51a33cc93b8d90f2611025ff7f3e6539e707de86fd9a507
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__3195a4a3cd982603dec093989818a9b10de0aea3609d08a8cb43f320ba2a2228(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.AutoScalingSpecificationProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b2219a43361bf3ff1d1bf29e1b2907d75a53df3b7016d534579938eea5d4e91d(
     value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.BillingModeProperty]],
 ) -> None:
@@ -1612,6 +2366,12 @@ def _typecheckingstub__c15490d5659aeda79f13514b12c87f518d6de130270ffd24df4af663b
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5733bf7940cc5b4e0c443c9b292d6c2f440a7bede5a0f631d4c1f894170bff53(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnTable.ReplicaSpecificationProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__8e1536df40ced7d731dcea97d7afa1eab0ec4b34824d105a20130aa6fafe98ef(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -1624,6 +2384,24 @@ def _typecheckingstub__4224e4814f153e9978b91f35f9c02cfe00615e65fb97b060775097a1c
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__2cb141a7c7ed6b1d9a39228641414ac62a7d79767996c73fe4911e45faa92ffd(
+    *,
+    auto_scaling_disabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    maximum_units: typing.Optional[jsii.Number] = None,
+    minimum_units: typing.Optional[jsii.Number] = None,
+    scaling_policy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ScalingPolicyProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__47c7d8efc57f0cc9c23ff9d319e31aa9f85ff8366a45b688f508d822b11eadd4(
+    *,
+    read_capacity_auto_scaling: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.AutoScalingSettingProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    write_capacity_auto_scaling: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.AutoScalingSettingProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__1b57c6da9515480ece2b86b6971f8563bcf0c49dab50c8c6e234c443b8c0f9a0(
     *,
     mode: builtins.str,
@@ -1664,10 +2442,37 @@ def _typecheckingstub__e82ecde232ad027f79eae23599756ec33659aabf2db7a5ba885d39917
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__06993df19646af34c044f18b07ace5cd635a3e192224fc5b9277509c659097ac(
+    *,
+    region: builtins.str,
+    read_capacity_auto_scaling: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.AutoScalingSettingProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    read_capacity_units: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__67fdfae50d59915fee6d91803c13e24de12b1573e762d8de76bc0cbeaba9a2d8(
+    *,
+    target_tracking_scaling_policy_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.TargetTrackingScalingPolicyConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__23200b02c7e7d1fd9b0336257d7f6dd749b95e0adc13464370ca6af1b666da1c(
+    *,
+    target_value: jsii.Number,
+    disable_scale_in: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    scale_in_cooldown: typing.Optional[jsii.Number] = None,
+    scale_out_cooldown: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__bd1ff29b1ec22382a7c3d14031657668106b0fcd843c06a96897bcadf10ffa92(
     *,
     keyspace_name: builtins.str,
     partition_key_columns: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ColumnProperty, typing.Dict[builtins.str, typing.Any]]]]],
+    auto_scaling_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.AutoScalingSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     billing_mode: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.BillingModeProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     clustering_key_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ClusteringKeyColumnProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -1675,6 +2480,7 @@ def _typecheckingstub__bd1ff29b1ec22382a7c3d14031657668106b0fcd843c06a96897bcadf
     encryption_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.EncryptionSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     point_in_time_recovery_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     regular_columns: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ColumnProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    replica_specifications: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.ReplicaSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     table_name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None: