aws-cdk-lib 2.173.4__py3-none-any.whl → 2.174.1__py3-none-any.whl

aws_cdk/aws_cassandra/__init__.py

@@ -77,7 +77,7 @@ class CfnKeyspace(
 ):
     '''You can use the ``AWS::Cassandra::Keyspace`` resource to create a new keyspace in Amazon Keyspaces (for Apache Cassandra).
 
-    For more information, see `Create a keyspace and a table <https://docs.aws.amazon.com/keyspaces/latest/devguide/getting-started.ddl.html>`_ in the *Amazon Keyspaces Developer Guide* .
+    For more information, see `Create a keyspace <https://docs.aws.amazon.com/keyspaces/latest/devguide/getting-started.keyspaces.html>`_ in the *Amazon Keyspaces Developer Guide* .
 
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-keyspace.html
     :cloudformationResource: AWS::Cassandra::Keyspace
@@ -90,6 +90,7 @@ class CfnKeyspace(
         from aws_cdk import aws_cassandra as cassandra
         
         cfn_keyspace = cassandra.CfnKeyspace(self, "MyCfnKeyspace",
+            client_side_timestamps_enabled=False,
             keyspace_name="keyspaceName",
             replication_specification=cassandra.CfnKeyspace.ReplicationSpecificationProperty(
                 region_list=["regionList"],
@@ -107,6 +108,7 @@ class CfnKeyspace(
         scope: _constructs_77d1e7e8.Construct,
         id: builtins.str,
         *,
+        client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         keyspace_name: typing.Optional[builtins.str] = None,
         replication_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnKeyspace.ReplicationSpecificationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -114,6 +116,7 @@ class CfnKeyspace(
         '''
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
+        :param client_side_timestamps_enabled: Indicates whether client-side timestamps are enabled (true) or disabled (false) for all tables in the keyspace. To add a Region to a single-Region keyspace with at least one table, the value must be set to true. After you've enabled client-side timestamps for a table, you can’t disable it again.
         :param keyspace_name: The name of the keyspace to be created. The keyspace name is case sensitive. If you don't specify a name, AWS CloudFormation generates a unique ID and uses that ID for the keyspace name. For more information, see `Name type <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html>`_ . *Length constraints:* Minimum length of 3. Maximum length of 255. *Pattern:* ``^[a-zA-Z0-9][a-zA-Z0-9_]{1,47}$``
         :param replication_specification: Specifies the ``ReplicationStrategy`` of a keyspace. The options are:. - ``SINGLE_REGION`` for a single Region keyspace (optional) or - ``MULTI_REGION`` for a multi-Region keyspace If no ``ReplicationStrategy`` is provided, the default is ``SINGLE_REGION`` . If you choose ``MULTI_REGION`` , you must also provide a ``RegionList`` with the AWS Regions that the keyspace is replicated in.
         :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>`_ .
@@ -123,6 +126,7 @@ class CfnKeyspace(
             check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = CfnKeyspaceProps(
+            client_side_timestamps_enabled=client_side_timestamps_enabled,
             keyspace_name=keyspace_name,
             replication_specification=replication_specification,
             tags=tags,
@@ -171,6 +175,24 @@ class CfnKeyspace(
         '''Tag Manager which manages the tags for this resource.'''
         return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))
 
+    @builtins.property
+    @jsii.member(jsii_name="clientSideTimestampsEnabled")
+    def client_side_timestamps_enabled(
+        self,
+    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+        '''Indicates whether client-side timestamps are enabled (true) or disabled (false) for all tables in the keyspace.'''
+        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], jsii.get(self, "clientSideTimestampsEnabled"))
+
+    @client_side_timestamps_enabled.setter
+    def client_side_timestamps_enabled(
+        self,
+        value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__fd8481bc3a8aed79ca56b1da03537eb72d1f39b5048347b1f8ac5f28b494a9e8)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "clientSideTimestampsEnabled", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="keyspaceName")
     def keyspace_name(self) -> typing.Optional[builtins.str]:
@@ -235,9 +257,11 @@ class CfnKeyspace(
         ) -> None:
             '''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.
+            The ``ReplicationSpecification`` property applies automatically to all tables in the keyspace.
+
+            To review the permissions that are required to add a new Region to a single-Region keyspace, see `Configure the IAM permissions required to add an AWS Region to a keyspace <https://docs.aws.amazon.com/keyspaces/latest/devguide/howitworks_replication_permissions_addReplica.html>`_ in the *Amazon Keyspaces Developer Guide* .
 
-            For more information, see `Multi-Region Replication <https://docs.aws.amazon.com/keyspaces/latest/devguide/multiRegion-replication.html>`_ in the *Amazon Keyspaces Developer Guide* .
+            For more information about multi-Region replication, see `Multi-Region replication <https://docs.aws.amazon.com/keyspaces/latest/devguide/multiRegion-replication.html>`_ in the *Amazon Keyspaces Developer Guide* .
 
             :param region_list: Specifies the AWS Regions that the keyspace is replicated in. You must specify at least two and up to six Regions, including the Region that the keyspace is being created in.
             :param replication_strategy: The options are:. - ``SINGLE_REGION`` (optional) - ``MULTI_REGION`` If no value is specified, the default is ``SINGLE_REGION`` . If ``MULTI_REGION`` is specified, ``RegionList`` is required.
@@ -307,6 +331,7 @@ class CfnKeyspace(
     jsii_type="aws-cdk-lib.aws_cassandra.CfnKeyspaceProps",
     jsii_struct_bases=[],
     name_mapping={
+        "client_side_timestamps_enabled": "clientSideTimestampsEnabled",
         "keyspace_name": "keyspaceName",
         "replication_specification": "replicationSpecification",
         "tags": "tags",
@@ -316,12 +341,14 @@ class CfnKeyspaceProps:
     def __init__(
         self,
         *,
+        client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
         keyspace_name: typing.Optional[builtins.str] = None,
         replication_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnKeyspace.ReplicationSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnKeyspace``.
 
+        :param client_side_timestamps_enabled: Indicates whether client-side timestamps are enabled (true) or disabled (false) for all tables in the keyspace. To add a Region to a single-Region keyspace with at least one table, the value must be set to true. After you've enabled client-side timestamps for a table, you can’t disable it again.
         :param keyspace_name: The name of the keyspace to be created. The keyspace name is case sensitive. If you don't specify a name, AWS CloudFormation generates a unique ID and uses that ID for the keyspace name. For more information, see `Name type <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-name.html>`_ . *Length constraints:* Minimum length of 3. Maximum length of 255. *Pattern:* ``^[a-zA-Z0-9][a-zA-Z0-9_]{1,47}$``
         :param replication_specification: Specifies the ``ReplicationStrategy`` of a keyspace. The options are:. - ``SINGLE_REGION`` for a single Region keyspace (optional) or - ``MULTI_REGION`` for a multi-Region keyspace If no ``ReplicationStrategy`` is provided, the default is ``SINGLE_REGION`` . If you choose ``MULTI_REGION`` , you must also provide a ``RegionList`` with the AWS Regions that the keyspace is replicated in.
         :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>`_ .
@@ -336,6 +363,7 @@ class CfnKeyspaceProps:
             from aws_cdk import aws_cassandra as cassandra
             
             cfn_keyspace_props = cassandra.CfnKeyspaceProps(
+                client_side_timestamps_enabled=False,
                 keyspace_name="keyspaceName",
                 replication_specification=cassandra.CfnKeyspace.ReplicationSpecificationProperty(
                     region_list=["regionList"],
@@ -349,10 +377,13 @@ class CfnKeyspaceProps:
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__bc0263cb98dfdfc7ed9f31cf986359bcc44c1b3f3c733ebb7d3e36b25fb4cea8)
+            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 keyspace_name", value=keyspace_name, expected_type=type_hints["keyspace_name"])
             check_type(argname="argument replication_specification", value=replication_specification, expected_type=type_hints["replication_specification"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if client_side_timestamps_enabled is not None:
+            self._values["client_side_timestamps_enabled"] = client_side_timestamps_enabled
         if keyspace_name is not None:
             self._values["keyspace_name"] = keyspace_name
         if replication_specification is not None:
@@ -360,6 +391,19 @@ class CfnKeyspaceProps:
         if tags is not None:
             self._values["tags"] = tags
 
+    @builtins.property
+    def client_side_timestamps_enabled(
+        self,
+    ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+        '''Indicates whether client-side timestamps are enabled (true) or disabled (false) for all tables in the keyspace.
+
+        To add a Region to a single-Region keyspace with at least one table, the value must be set to true. After you've enabled client-side timestamps for a table, you can’t disable it again.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-keyspace.html#cfn-cassandra-keyspace-clientsidetimestampsenabled
+        '''
+        result = self._values.get("client_side_timestamps_enabled")
+        return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
     @builtins.property
     def keyspace_name(self) -> typing.Optional[builtins.str]:
         '''The name of the keyspace to be created.
@@ -422,7 +466,7 @@ class CfnTable(
 ):
     '''You can use the ``AWS::Cassandra::Table`` resource to create a new table in Amazon Keyspaces (for Apache Cassandra).
 
-    For more information, see `Create a keyspace and a table <https://docs.aws.amazon.com/keyspaces/latest/devguide/getting-started.ddl.html>`_ in the *Amazon Keyspaces Developer Guide* .
+    For more information, see `Create a table <https://docs.aws.amazon.com/keyspaces/latest/devguide/getting-started.tables.html>`_ in the *Amazon Keyspaces Developer Guide* .
 
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-table.html
     :cloudformationResource: AWS::Cassandra::Table
@@ -2224,11 +2268,373 @@ class CfnTableProps:
         )
 
 
+@jsii.implements(_IInspectable_c2943556)
+class CfnType(
+    _CfnResource_9df397a6,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_cassandra.CfnType",
+):
+    '''The ``CreateType`` operation creates a new user-defined type in the specified keyspace.
+
+    To configure the required permissions, see `Permissions to create a UDT <https://docs.aws.amazon.com/keyspaces/latest/devguide/configure-udt-permissions.html#udt-permissions-create>`_ in the *Amazon Keyspaces Developer Guide* .
+
+    For more information, see `User-defined types (UDTs) <https://docs.aws.amazon.com/keyspaces/latest/devguide/udts.html>`_ in the *Amazon Keyspaces Developer Guide* .
+
+    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-type.html
+    :cloudformationResource: AWS::Cassandra::Type
+    :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
+        
+        cfn_type = cassandra.CfnType(self, "MyCfnType",
+            fields=[cassandra.CfnType.FieldProperty(
+                field_name="fieldName",
+                field_type="fieldType"
+            )],
+            keyspace_name="keyspaceName",
+            type_name="typeName"
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        fields: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnType.FieldProperty", typing.Dict[builtins.str, typing.Any]]]]],
+        keyspace_name: builtins.str,
+        type_name: builtins.str,
+    ) -> None:
+        '''
+        :param scope: Scope in which this resource is defined.
+        :param id: Construct identifier for this resource (unique in its scope).
+        :param fields: A list of fields that define this type.
+        :param keyspace_name: The name of the keyspace to create the type in. The keyspace must already exist.
+        :param type_name: The name of the user-defined type. UDT names must contain 48 characters or less, must begin with an alphabetic character, and can only contain alpha-numeric characters and underscores. Amazon Keyspaces converts upper case characters automatically into lower case characters. For more information, see `Create a user-defined type (UDT) in Amazon Keyspaces <https://docs.aws.amazon.com/keyspaces/latest/devguide/keyspaces-create-udt.html>`_ in the *Amazon Keyspaces Developer Guide* .
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__fdf5bf6ac8d9d8fc5456b7448fd00dc522384b607e1c447a244fbd1a94a7e2c3)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CfnTypeProps(
+            fields=fields, keyspace_name=keyspace_name, type_name=type_name
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="inspect")
+    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
+        '''Examines the CloudFormation resource and discloses attributes.
+
+        :param inspector: tree inspector to collect and process attributes.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d0b9082e2193b209827110d3aa56f16ca3c3a11c24cb6caeaa3fa6467e41c367)
+            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
+        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))
+
+    @jsii.member(jsii_name="renderProperties")
+    def _render_properties(
+        self,
+        props: typing.Mapping[builtins.str, typing.Any],
+    ) -> typing.Mapping[builtins.str, typing.Any]:
+        '''
+        :param props: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__424eac90bc15b9127c3abf068efdbd3c37e3ffacf615e7878911972302059411)
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
+    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
+        '''The CloudFormation resource type name for this resource class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))
+
+    @builtins.property
+    @jsii.member(jsii_name="attrDirectParentTypes")
+    def attr_direct_parent_types(self) -> typing.List[builtins.str]:
+        '''A list of user-defined types that use this type.
+
+        :cloudformationAttribute: DirectParentTypes
+        '''
+        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrDirectParentTypes"))
+
+    @builtins.property
+    @jsii.member(jsii_name="attrDirectReferringTables")
+    def attr_direct_referring_tables(self) -> typing.List[builtins.str]:
+        '''A list of tables that use this type.
+
+        :cloudformationAttribute: DirectReferringTables
+        '''
+        return typing.cast(typing.List[builtins.str], jsii.get(self, "attrDirectReferringTables"))
+
+    @builtins.property
+    @jsii.member(jsii_name="attrKeyspaceArn")
+    def attr_keyspace_arn(self) -> builtins.str:
+        '''The unique identifier of the keyspace that contains this type in the format of Amazon Resource Name (ARN).
+
+        :cloudformationAttribute: KeyspaceArn
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "attrKeyspaceArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="attrLastModifiedTimestamp")
+    def attr_last_modified_timestamp(self) -> _IResolvable_da3f097b:
+        '''The last time this type was modified.
+
+        :cloudformationAttribute: LastModifiedTimestamp
+        '''
+        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrLastModifiedTimestamp"))
+
+    @builtins.property
+    @jsii.member(jsii_name="attrMaxNestingDepth")
+    def attr_max_nesting_depth(self) -> jsii.Number:
+        '''The maximum nesting depth of this type.
+
+        For more information, see `Amazon Keyspaces UDT quotas and default values <https://docs.aws.amazon.com/keyspaces/latest/devguide/quotas.html#quotas-udts>`_ in the *Amazon Keyspaces Developer Guide* .
+
+        :cloudformationAttribute: MaxNestingDepth
+        '''
+        return typing.cast(jsii.Number, jsii.get(self, "attrMaxNestingDepth"))
+
+    @builtins.property
+    @jsii.member(jsii_name="cfnProperties")
+    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
+
+    @builtins.property
+    @jsii.member(jsii_name="fields")
+    def fields(
+        self,
+    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnType.FieldProperty"]]]:
+        '''A list of fields that define this type.'''
+        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnType.FieldProperty"]]], jsii.get(self, "fields"))
+
+    @fields.setter
+    def fields(
+        self,
+        value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnType.FieldProperty"]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ca4dbc25b8389c762695ecb965e0cd985e70c9dae5c5a02153927c352e82d0a4)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "fields", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="keyspaceName")
+    def keyspace_name(self) -> builtins.str:
+        '''The name of the keyspace to create the type in.'''
+        return typing.cast(builtins.str, jsii.get(self, "keyspaceName"))
+
+    @keyspace_name.setter
+    def keyspace_name(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__3f21da74adafb3839ebabb5326e3d975cafd05abe6458f5914d77c169be2418b)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "keyspaceName", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="typeName")
+    def type_name(self) -> builtins.str:
+        '''The name of the user-defined type.'''
+        return typing.cast(builtins.str, jsii.get(self, "typeName"))
+
+    @type_name.setter
+    def type_name(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__606db280be88e96db966d3665a4a5153b9ee5f616f60ff1d292682aa13ba4bd9)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "typeName", value) # pyright: ignore[reportArgumentType]
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_cassandra.CfnType.FieldProperty",
+        jsii_struct_bases=[],
+        name_mapping={"field_name": "fieldName", "field_type": "fieldType"},
+    )
+    class FieldProperty:
+        def __init__(
+            self,
+            *,
+            field_name: builtins.str,
+            field_type: builtins.str,
+        ) -> None:
+            '''The name and data type of an individual field in a user-defined type (UDT).
+
+            In addition to a Cassandra data type, you can also use another UDT. When you nest another UDT or collection data type, you have to declare them with the ``FROZEN`` keyword.
+
+            :param field_name: The name of the field.
+            :param field_type: The data type of the field. This can be any Cassandra data type or another user-defined type.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-type-field.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
+                
+                field_property = cassandra.CfnType.FieldProperty(
+                    field_name="fieldName",
+                    field_type="fieldType"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__54b1c8332ddb6073a9eb0924c6e34b60d337092a8c288e7dba5abbe358ef2718)
+                check_type(argname="argument field_name", value=field_name, expected_type=type_hints["field_name"])
+                check_type(argname="argument field_type", value=field_type, expected_type=type_hints["field_type"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "field_name": field_name,
+                "field_type": field_type,
+            }
+
+        @builtins.property
+        def field_name(self) -> builtins.str:
+            '''The name of the field.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-type-field.html#cfn-cassandra-type-field-fieldname
+            '''
+            result = self._values.get("field_name")
+            assert result is not None, "Required property 'field_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def field_type(self) -> builtins.str:
+            '''The data type of the field.
+
+            This can be any Cassandra data type or another user-defined type.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cassandra-type-field.html#cfn-cassandra-type-field-fieldtype
+            '''
+            result = self._values.get("field_type")
+            assert result is not None, "Required property 'field_type' is missing"
+            return typing.cast(builtins.str, 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 "FieldProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_cassandra.CfnTypeProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "fields": "fields",
+        "keyspace_name": "keyspaceName",
+        "type_name": "typeName",
+    },
+)
+class CfnTypeProps:
+    def __init__(
+        self,
+        *,
+        fields: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnType.FieldProperty, typing.Dict[builtins.str, typing.Any]]]]],
+        keyspace_name: builtins.str,
+        type_name: builtins.str,
+    ) -> None:
+        '''Properties for defining a ``CfnType``.
+
+        :param fields: A list of fields that define this type.
+        :param keyspace_name: The name of the keyspace to create the type in. The keyspace must already exist.
+        :param type_name: The name of the user-defined type. UDT names must contain 48 characters or less, must begin with an alphabetic character, and can only contain alpha-numeric characters and underscores. Amazon Keyspaces converts upper case characters automatically into lower case characters. For more information, see `Create a user-defined type (UDT) in Amazon Keyspaces <https://docs.aws.amazon.com/keyspaces/latest/devguide/keyspaces-create-udt.html>`_ in the *Amazon Keyspaces Developer Guide* .
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-type.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
+            
+            cfn_type_props = cassandra.CfnTypeProps(
+                fields=[cassandra.CfnType.FieldProperty(
+                    field_name="fieldName",
+                    field_type="fieldType"
+                )],
+                keyspace_name="keyspaceName",
+                type_name="typeName"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__bd25d8d93ed6a818dbba7d01a55023377acd68fed479388d8e01055d8b18bb90)
+            check_type(argname="argument fields", value=fields, expected_type=type_hints["fields"])
+            check_type(argname="argument keyspace_name", value=keyspace_name, expected_type=type_hints["keyspace_name"])
+            check_type(argname="argument type_name", value=type_name, expected_type=type_hints["type_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "fields": fields,
+            "keyspace_name": keyspace_name,
+            "type_name": type_name,
+        }
+
+    @builtins.property
+    def fields(
+        self,
+    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnType.FieldProperty]]]:
+        '''A list of fields that define this type.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-type.html#cfn-cassandra-type-fields
+        '''
+        result = self._values.get("fields")
+        assert result is not None, "Required property 'fields' is missing"
+        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnType.FieldProperty]]], result)
+
+    @builtins.property
+    def keyspace_name(self) -> builtins.str:
+        '''The name of the keyspace to create the type in.
+
+        The keyspace must already exist.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-type.html#cfn-cassandra-type-keyspacename
+        '''
+        result = self._values.get("keyspace_name")
+        assert result is not None, "Required property 'keyspace_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def type_name(self) -> builtins.str:
+        '''The name of the user-defined type.
+
+        UDT names must contain 48 characters or less, must begin with an alphabetic character, and can only contain alpha-numeric characters and underscores. Amazon Keyspaces converts upper case characters automatically into lower case characters. For more information, see `Create a user-defined type (UDT) in Amazon Keyspaces <https://docs.aws.amazon.com/keyspaces/latest/devguide/keyspaces-create-udt.html>`_ in the *Amazon Keyspaces Developer Guide* .
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cassandra-type.html#cfn-cassandra-type-typename
+        '''
+        result = self._values.get("type_name")
+        assert result is not None, "Required property 'type_name' is missing"
+        return typing.cast(builtins.str, 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 "CfnTypeProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 __all__ = [
     "CfnKeyspace",
     "CfnKeyspaceProps",
     "CfnTable",
     "CfnTableProps",
+    "CfnType",
+    "CfnTypeProps",
 ]
 
 publication.publish()
@@ -2237,6 +2643,7 @@ def _typecheckingstub__9cd64888a8d1139f7fef90a6f2cad1bf287a6d09115cfa1d1147c1afd
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
+    client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     keyspace_name: typing.Optional[builtins.str] = None,
     replication_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnKeyspace.ReplicationSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -2256,6 +2663,12 @@ def _typecheckingstub__42f60f7b87e845a932e67441bed6a8227df77e1b7945146e65d3ba8ac
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__fd8481bc3a8aed79ca56b1da03537eb72d1f39b5048347b1f8ac5f28b494a9e8(
+    value: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__5fb7166642fd3aff60742c5e03d8f0094ff2d3ed08ad9f239837dfa2ef308f38(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -2284,6 +2697,7 @@ def _typecheckingstub__e5f12bad7b518911e0710e02ed64e0533c1123f35e304844dab5aaae8
 
 def _typecheckingstub__bc0263cb98dfdfc7ed9f31cf986359bcc44c1b3f3c733ebb7d3e36b25fb4cea8(
     *,
+    client_side_timestamps_enabled: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     keyspace_name: typing.Optional[builtins.str] = None,
     replication_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnKeyspace.ReplicationSpecificationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -2504,3 +2918,61 @@ def _typecheckingstub__bd1ff29b1ec22382a7c3d14031657668106b0fcd843c06a96897bcadf
 ) -> None:
     """Type checking stubs"""
     pass
+
+def _typecheckingstub__fdf5bf6ac8d9d8fc5456b7448fd00dc522384b607e1c447a244fbd1a94a7e2c3(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    fields: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnType.FieldProperty, typing.Dict[builtins.str, typing.Any]]]]],
+    keyspace_name: builtins.str,
+    type_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__d0b9082e2193b209827110d3aa56f16ca3c3a11c24cb6caeaa3fa6467e41c367(
+    inspector: _TreeInspector_488e0dd5,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__424eac90bc15b9127c3abf068efdbd3c37e3ffacf615e7878911972302059411(
+    props: typing.Mapping[builtins.str, typing.Any],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ca4dbc25b8389c762695ecb965e0cd985e70c9dae5c5a02153927c352e82d0a4(
+    value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnType.FieldProperty]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__3f21da74adafb3839ebabb5326e3d975cafd05abe6458f5914d77c169be2418b(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__606db280be88e96db966d3665a4a5153b9ee5f616f60ff1d292682aa13ba4bd9(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__54b1c8332ddb6073a9eb0924c6e34b60d337092a8c288e7dba5abbe358ef2718(
+    *,
+    field_name: builtins.str,
+    field_type: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__bd25d8d93ed6a818dbba7d01a55023377acd68fed479388d8e01055d8b18bb90(
+    *,
+    fields: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnType.FieldProperty, typing.Dict[builtins.str, typing.Any]]]]],
+    keyspace_name: builtins.str,
+    type_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass