aws-cdk.aws-s3tables-alpha 2.208.0a0__py3-none-any.whl → 2.209.1a0__py3-none-any.whl

aws_cdk/aws_s3tables_alpha/__init__.py

@@ -38,6 +38,57 @@ sample_table_bucket = TableBucket(scope, "ExampleTableBucket",
 )
 ```
 
+### Define an S3 Tables Namespace
+
+```python
+# Build a namespace
+sample_namespace = Namespace(scope, "ExampleNamespace",
+    namespace_name="example-namespace-1",
+    table_bucket=table_bucket
+)
+```
+
+### Define an S3 Table
+
+```python
+# Build a table
+sample_table = Table(scope, "ExampleTable",
+    table_name="example_table",
+    namespace=namespace,
+    open_table_format=OpenTableFormat.ICEBERG,
+    without_metadata=True
+)
+
+# Build a table with an Iceberg Schema
+sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+    table_name="example_table_with_schema",
+    namespace=namespace,
+    open_table_format=OpenTableFormat.ICEBERG,
+    iceberg_metadata=IcebergMetadataProperty(
+        iceberg_schema=IcebergSchemaProperty(
+            schema_field_list=[SchemaFieldProperty(
+                name="id",
+                type="int",
+                required=True
+            ), SchemaFieldProperty(
+                name="name",
+                type="string"
+            )
+            ]
+        )
+    ),
+    compaction=CompactionProperty(
+        status=Status.ENABLED,
+        target_file_size_mb=128
+    ),
+    snapshot_management=SnapshotManagementProperty(
+        status=Status.ENABLED,
+        max_snapshot_age_hours=48,
+        min_snapshots_to_keep=5
+    )
+)
+```
+
 Learn more about table buckets maintenance operations and default behavior from the [S3 Tables User Guide](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html)
 
 ### Controlling Table Bucket Permissions
@@ -109,8 +160,8 @@ encrypted_bucket_auto = TableBucket(scope, "EncryptedTableBucketAuto",
 
 L2 Construct support for:
 
-* Namespaces
-* Tables
+* Table Policy
+* KMS encryption support for Tables
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
@@ -150,6 +201,267 @@ import aws_cdk.aws_kms as _aws_cdk_aws_kms_ceddda9d
 import constructs as _constructs_77d1e7e8
 
 
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.CompactionProperty",
+    jsii_struct_bases=[],
+    name_mapping={"status": "status", "target_file_size_mb": "targetFileSizeMb"},
+)
+class CompactionProperty:
+    def __init__(self, *, status: "Status", target_file_size_mb: jsii.Number) -> None:
+        '''(experimental) Settings governing the Compaction maintenance action.
+
+        :param status: (experimental) Status of the compaction maintenance action.
+        :param target_file_size_mb: (experimental) Target file size in megabytes for compaction.
+
+        :default: - No compaction settings
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            # Build a table
+            sample_table = Table(scope, "ExampleTable",
+                table_name="example_table",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                without_metadata=True
+            )
+            
+            # Build a table with an Iceberg Schema
+            sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+                table_name="example_table_with_schema",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                iceberg_metadata=IcebergMetadataProperty(
+                    iceberg_schema=IcebergSchemaProperty(
+                        schema_field_list=[SchemaFieldProperty(
+                            name="id",
+                            type="int",
+                            required=True
+                        ), SchemaFieldProperty(
+                            name="name",
+                            type="string"
+                        )
+                        ]
+                    )
+                ),
+                compaction=CompactionProperty(
+                    status=Status.ENABLED,
+                    target_file_size_mb=128
+                ),
+                snapshot_management=SnapshotManagementProperty(
+                    status=Status.ENABLED,
+                    max_snapshot_age_hours=48,
+                    min_snapshots_to_keep=5
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ea606cde59917b73fdb198d73eabdbbe686fdbd73e01ef72284a9061ea612d80)
+            check_type(argname="argument status", value=status, expected_type=type_hints["status"])
+            check_type(argname="argument target_file_size_mb", value=target_file_size_mb, expected_type=type_hints["target_file_size_mb"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "status": status,
+            "target_file_size_mb": target_file_size_mb,
+        }
+
+    @builtins.property
+    def status(self) -> "Status":
+        '''(experimental) Status of the compaction maintenance action.
+
+        :stability: experimental
+        '''
+        result = self._values.get("status")
+        assert result is not None, "Required property 'status' is missing"
+        return typing.cast("Status", result)
+
+    @builtins.property
+    def target_file_size_mb(self) -> jsii.Number:
+        '''(experimental) Target file size in megabytes for compaction.
+
+        :stability: experimental
+        '''
+        result = self._values.get("target_file_size_mb")
+        assert result is not None, "Required property 'target_file_size_mb' is missing"
+        return typing.cast(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 "CompactionProperty(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.interface(jsii_type="@aws-cdk/aws-s3tables-alpha.INamespace")
+class INamespace(_aws_cdk_ceddda9d.IResource, typing_extensions.Protocol):
+    '''(experimental) Represents an S3 Tables Namespace.
+
+    :stability: experimental
+    '''
+
+    @builtins.property
+    @jsii.member(jsii_name="namespaceName")
+    def namespace_name(self) -> builtins.str:
+        '''(experimental) The name of this namespace.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="tableBucket")
+    def table_bucket(self) -> "ITableBucket":
+        '''(experimental) The table bucket which this namespace belongs to.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+
+class _INamespaceProxy(
+    jsii.proxy_for(_aws_cdk_ceddda9d.IResource), # type: ignore[misc]
+):
+    '''(experimental) Represents an S3 Tables Namespace.
+
+    :stability: experimental
+    '''
+
+    __jsii_type__: typing.ClassVar[str] = "@aws-cdk/aws-s3tables-alpha.INamespace"
+
+    @builtins.property
+    @jsii.member(jsii_name="namespaceName")
+    def namespace_name(self) -> builtins.str:
+        '''(experimental) The name of this namespace.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "namespaceName"))
+
+    @builtins.property
+    @jsii.member(jsii_name="tableBucket")
+    def table_bucket(self) -> "ITableBucket":
+        '''(experimental) The table bucket which this namespace belongs to.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast("ITableBucket", jsii.get(self, "tableBucket"))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, INamespace).__jsii_proxy_class__ = lambda : _INamespaceProxy
+
+
+@jsii.interface(jsii_type="@aws-cdk/aws-s3tables-alpha.ITable")
+class ITable(_aws_cdk_ceddda9d.IResource, typing_extensions.Protocol):
+    '''(experimental) Represents an S3 Table.
+
+    :stability: experimental
+    '''
+
+    @builtins.property
+    @jsii.member(jsii_name="tableArn")
+    def table_arn(self) -> builtins.str:
+        '''(experimental) The ARN of this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="tableName")
+    def table_name(self) -> builtins.str:
+        '''(experimental) The name of this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="account")
+    def account(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The accountId containing this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+    @builtins.property
+    @jsii.member(jsii_name="region")
+    def region(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The region containing this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        ...
+
+
+class _ITableProxy(
+    jsii.proxy_for(_aws_cdk_ceddda9d.IResource), # type: ignore[misc]
+):
+    '''(experimental) Represents an S3 Table.
+
+    :stability: experimental
+    '''
+
+    __jsii_type__: typing.ClassVar[str] = "@aws-cdk/aws-s3tables-alpha.ITable"
+
+    @builtins.property
+    @jsii.member(jsii_name="tableArn")
+    def table_arn(self) -> builtins.str:
+        '''(experimental) The ARN of this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "tableArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="tableName")
+    def table_name(self) -> builtins.str:
+        '''(experimental) The name of this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "tableName"))
+
+    @builtins.property
+    @jsii.member(jsii_name="account")
+    def account(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The accountId containing this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "account"))
+
+    @builtins.property
+    @jsii.member(jsii_name="region")
+    def region(self) -> typing.Optional[builtins.str]:
+        '''(experimental) The region containing this table.
+
+        :stability: experimental
+        :attribute: true
+        '''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "region"))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, ITable).__jsii_proxy_class__ = lambda : _ITableProxy
+
+
 @jsii.interface(jsii_type="@aws-cdk/aws-s3tables-alpha.ITableBucket")
 class ITableBucket(_aws_cdk_ceddda9d.IResource, typing_extensions.Protocol):
     '''(experimental) Interface definition for S3 Table Buckets.
@@ -388,63 +700,1066 @@ class _ITableBucketProxy(
         If encryption is used, permission to use the key to decrypt the contents
         of the bucket will also be granted to the same principal.
 
-        :param identity: The principal to allow read permissions to.
-        :param table_id: Allow the permissions to all tables using '*' or to single table by its unique ID.
+        :param identity: The principal to allow read permissions to.
+        :param table_id: Allow the permissions to all tables using '*' or to single table by its unique ID.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__853d3e698d103ae1fe304d2239745ee798278fcd22f673c7ae8e9b33884c90a9)
+            check_type(argname="argument identity", value=identity, expected_type=type_hints["identity"])
+            check_type(argname="argument table_id", value=table_id, expected_type=type_hints["table_id"])
+        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [identity, table_id]))
+
+    @jsii.member(jsii_name="grantReadWrite")
+    def grant_read_write(
+        self,
+        identity: _aws_cdk_aws_iam_ceddda9d.IGrantable,
+        table_id: builtins.str,
+    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
+        '''(experimental) Grant read and write permissions for this table bucket and its tables to an IAM principal (Role/Group/User).
+
+        If encryption is used, permission to use the key to encrypt/decrypt the contents
+        of the bucket will also be granted to the same principal.
+
+        :param identity: The principal to allow read and write permissions to.
+        :param table_id: Allow the permissions to all tables using '*' or to single table by its unique ID.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1c9eb5186509f26b2c015223d6e2614c16cc34d5c2608ca3903b133360e23990)
+            check_type(argname="argument identity", value=identity, expected_type=type_hints["identity"])
+            check_type(argname="argument table_id", value=table_id, expected_type=type_hints["table_id"])
+        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantReadWrite", [identity, table_id]))
+
+    @jsii.member(jsii_name="grantWrite")
+    def grant_write(
+        self,
+        identity: _aws_cdk_aws_iam_ceddda9d.IGrantable,
+        table_id: builtins.str,
+    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
+        '''(experimental) Grant write permissions for this table bucket and its tables to an IAM principal (Role/Group/User).
+
+        If encryption is used, permission to use the key to encrypt the contents
+        of the bucket will also be granted to the same principal.
+
+        :param identity: The principal to allow write permissions to.
+        :param table_id: Allow the permissions to all tables using '*' or to single table by its unique ID.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__65fa831e505e76e1fe23a8a8d8ce97bb97ebff683edbf67f37020df64c040fdb)
+            check_type(argname="argument identity", value=identity, expected_type=type_hints["identity"])
+            check_type(argname="argument table_id", value=table_id, expected_type=type_hints["table_id"])
+        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantWrite", [identity, table_id]))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, ITableBucket).__jsii_proxy_class__ = lambda : _ITableBucketProxy
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.IcebergMetadataProperty",
+    jsii_struct_bases=[],
+    name_mapping={"iceberg_schema": "icebergSchema"},
+)
+class IcebergMetadataProperty:
+    def __init__(
+        self,
+        *,
+        iceberg_schema: typing.Union["IcebergSchemaProperty", typing.Dict[builtins.str, typing.Any]],
+    ) -> None:
+        '''(experimental) Contains details about the metadata for an Iceberg table.
+
+        :param iceberg_schema: (experimental) Contains details about the schema for an Iceberg table.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3tables-table-icebergmetadata.html
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            # Build a table
+            sample_table = Table(scope, "ExampleTable",
+                table_name="example_table",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                without_metadata=True
+            )
+            
+            # Build a table with an Iceberg Schema
+            sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+                table_name="example_table_with_schema",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                iceberg_metadata=IcebergMetadataProperty(
+                    iceberg_schema=IcebergSchemaProperty(
+                        schema_field_list=[SchemaFieldProperty(
+                            name="id",
+                            type="int",
+                            required=True
+                        ), SchemaFieldProperty(
+                            name="name",
+                            type="string"
+                        )
+                        ]
+                    )
+                ),
+                compaction=CompactionProperty(
+                    status=Status.ENABLED,
+                    target_file_size_mb=128
+                ),
+                snapshot_management=SnapshotManagementProperty(
+                    status=Status.ENABLED,
+                    max_snapshot_age_hours=48,
+                    min_snapshots_to_keep=5
+                )
+            )
+        '''
+        if isinstance(iceberg_schema, dict):
+            iceberg_schema = IcebergSchemaProperty(**iceberg_schema)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__f8230e6a4eadd2193ba7389b1a23bde451e68a07c19bcda56cba1c321d75d5f0)
+            check_type(argname="argument iceberg_schema", value=iceberg_schema, expected_type=type_hints["iceberg_schema"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "iceberg_schema": iceberg_schema,
+        }
+
+    @builtins.property
+    def iceberg_schema(self) -> "IcebergSchemaProperty":
+        '''(experimental) Contains details about the schema for an Iceberg table.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3tables-table-icebergmetadata.html#cfn-s3tables-table-icebergmetadata-icebergschema
+        :stability: experimental
+        '''
+        result = self._values.get("iceberg_schema")
+        assert result is not None, "Required property 'iceberg_schema' is missing"
+        return typing.cast("IcebergSchemaProperty", 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 "IcebergMetadataProperty(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.IcebergSchemaProperty",
+    jsii_struct_bases=[],
+    name_mapping={"schema_field_list": "schemaFieldList"},
+)
+class IcebergSchemaProperty:
+    def __init__(
+        self,
+        *,
+        schema_field_list: typing.Sequence[typing.Union["SchemaFieldProperty", typing.Dict[builtins.str, typing.Any]]],
+    ) -> None:
+        '''(experimental) Contains details about the schema for an Iceberg table.
+
+        :param schema_field_list: (experimental) Contains details about the schema for an Iceberg table.
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            # Build a table
+            sample_table = Table(scope, "ExampleTable",
+                table_name="example_table",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                without_metadata=True
+            )
+            
+            # Build a table with an Iceberg Schema
+            sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+                table_name="example_table_with_schema",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                iceberg_metadata=IcebergMetadataProperty(
+                    iceberg_schema=IcebergSchemaProperty(
+                        schema_field_list=[SchemaFieldProperty(
+                            name="id",
+                            type="int",
+                            required=True
+                        ), SchemaFieldProperty(
+                            name="name",
+                            type="string"
+                        )
+                        ]
+                    )
+                ),
+                compaction=CompactionProperty(
+                    status=Status.ENABLED,
+                    target_file_size_mb=128
+                ),
+                snapshot_management=SnapshotManagementProperty(
+                    status=Status.ENABLED,
+                    max_snapshot_age_hours=48,
+                    min_snapshots_to_keep=5
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__f4da2961c1ead632b855491f63cf76c4886c0e7a3d1795c1533655124a5dccb6)
+            check_type(argname="argument schema_field_list", value=schema_field_list, expected_type=type_hints["schema_field_list"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "schema_field_list": schema_field_list,
+        }
+
+    @builtins.property
+    def schema_field_list(self) -> typing.List["SchemaFieldProperty"]:
+        '''(experimental) Contains details about the schema for an Iceberg table.
+
+        :stability: experimental
+        '''
+        result = self._values.get("schema_field_list")
+        assert result is not None, "Required property 'schema_field_list' is missing"
+        return typing.cast(typing.List["SchemaFieldProperty"], 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 "IcebergSchemaProperty(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.implements(INamespace)
+class Namespace(
+    _aws_cdk_ceddda9d.Resource,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="@aws-cdk/aws-s3tables-alpha.Namespace",
+):
+    '''(experimental) An S3 Tables Namespace with helpers.
+
+    A namespace is a logical container for tables within a table bucket.
+
+    :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        # Build a namespace
+        sample_namespace = Namespace(scope, "ExampleNamespace",
+            namespace_name="example-namespace-1",
+            table_bucket=table_bucket
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        namespace_name: builtins.str,
+        table_bucket: ITableBucket,
+        removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param namespace_name: (experimental) A name for the namespace.
+        :param table_bucket: (experimental) The table bucket this namespace belongs to.
+        :param removal_policy: (experimental) Policy to apply when the policy is removed from this stack. Default: RemovalPolicy.DESTROY
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ea3444f2b1f25cee0bac27bf1e4c044f18ded5f025356448c35a47f4611915d5)
+            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 = NamespaceProps(
+            namespace_name=namespace_name,
+            table_bucket=table_bucket,
+            removal_policy=removal_policy,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="fromNamespaceAttributes")
+    @builtins.classmethod
+    def from_namespace_attributes(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        namespace_name: builtins.str,
+        table_bucket: ITableBucket,
+    ) -> INamespace:
+        '''(experimental) Import an existing namespace from its attributes.
+
+        :param scope: -
+        :param id: -
+        :param namespace_name: (experimental) The name of the namespace.
+        :param table_bucket: (experimental) The table bucket this namespace belongs to.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__429e6100662356607de36bc4f09397c07482d4becdff99cdf1257c1b95547276)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        attrs = NamespaceAttributes(
+            namespace_name=namespace_name, table_bucket=table_bucket
+        )
+
+        return typing.cast(INamespace, jsii.sinvoke(cls, "fromNamespaceAttributes", [scope, id, attrs]))
+
+    @jsii.member(jsii_name="validateNamespaceName")
+    @builtins.classmethod
+    def validate_namespace_name(cls, namespace_name: builtins.str) -> None:
+        '''(experimental) See https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets-naming.html.
+
+        :param namespace_name: Name of the namespace.
+
+        :stability: experimental
+        :throws: UnscopedValidationError if any naming errors are detected
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4a07351eb257958d2290e548252c46a7c8963c7bc2f700e83671f819e4b7dbd5)
+            check_type(argname="argument namespace_name", value=namespace_name, expected_type=type_hints["namespace_name"])
+        return typing.cast(None, jsii.sinvoke(cls, "validateNamespaceName", [namespace_name]))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''(experimental) Uniquely identifies this class.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
+    @builtins.property
+    @jsii.member(jsii_name="namespaceName")
+    def namespace_name(self) -> builtins.str:
+        '''(experimental) The name of this namespace.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "namespaceName"))
+
+    @builtins.property
+    @jsii.member(jsii_name="tableBucket")
+    def table_bucket(self) -> ITableBucket:
+        '''(experimental) The table bucket which this namespace belongs to.
+
+        :stability: experimental
+        '''
+        return typing.cast(ITableBucket, jsii.get(self, "tableBucket"))
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.NamespaceAttributes",
+    jsii_struct_bases=[],
+    name_mapping={"namespace_name": "namespaceName", "table_bucket": "tableBucket"},
+)
+class NamespaceAttributes:
+    def __init__(
+        self,
+        *,
+        namespace_name: builtins.str,
+        table_bucket: ITableBucket,
+    ) -> None:
+        '''(experimental) Attributes for importing an existing namespace.
+
+        :param namespace_name: (experimental) The name of the namespace.
+        :param table_bucket: (experimental) The table bucket this namespace belongs to.
+
+        :stability: experimental
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk.aws_s3tables_alpha as s3tables_alpha
+            
+            # table_bucket: s3tables_alpha.TableBucket
+            
+            namespace_attributes = s3tables_alpha.NamespaceAttributes(
+                namespace_name="namespaceName",
+                table_bucket=table_bucket
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__8f79f8c2998fe357462fbff82a75e82ed3236dd34caffcf6f6267cffcdda3275)
+            check_type(argname="argument namespace_name", value=namespace_name, expected_type=type_hints["namespace_name"])
+            check_type(argname="argument table_bucket", value=table_bucket, expected_type=type_hints["table_bucket"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "namespace_name": namespace_name,
+            "table_bucket": table_bucket,
+        }
+
+    @builtins.property
+    def namespace_name(self) -> builtins.str:
+        '''(experimental) The name of the namespace.
+
+        :stability: experimental
+        '''
+        result = self._values.get("namespace_name")
+        assert result is not None, "Required property 'namespace_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def table_bucket(self) -> ITableBucket:
+        '''(experimental) The table bucket this namespace belongs to.
+
+        :stability: experimental
+        '''
+        result = self._values.get("table_bucket")
+        assert result is not None, "Required property 'table_bucket' is missing"
+        return typing.cast(ITableBucket, 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 "NamespaceAttributes(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.NamespaceProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "namespace_name": "namespaceName",
+        "table_bucket": "tableBucket",
+        "removal_policy": "removalPolicy",
+    },
+)
+class NamespaceProps:
+    def __init__(
+        self,
+        *,
+        namespace_name: builtins.str,
+        table_bucket: ITableBucket,
+        removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+    ) -> None:
+        '''(experimental) Parameters for constructing a Namespace.
+
+        :param namespace_name: (experimental) A name for the namespace.
+        :param table_bucket: (experimental) The table bucket this namespace belongs to.
+        :param removal_policy: (experimental) Policy to apply when the policy is removed from this stack. Default: RemovalPolicy.DESTROY
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            # Build a namespace
+            sample_namespace = Namespace(scope, "ExampleNamespace",
+                namespace_name="example-namespace-1",
+                table_bucket=table_bucket
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__fd18f87a98f23ccaea0f0c36db6b294de2ffbbb509594c9bfa49f26b6b0d0e7a)
+            check_type(argname="argument namespace_name", value=namespace_name, expected_type=type_hints["namespace_name"])
+            check_type(argname="argument table_bucket", value=table_bucket, expected_type=type_hints["table_bucket"])
+            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "namespace_name": namespace_name,
+            "table_bucket": table_bucket,
+        }
+        if removal_policy is not None:
+            self._values["removal_policy"] = removal_policy
+
+    @builtins.property
+    def namespace_name(self) -> builtins.str:
+        '''(experimental) A name for the namespace.
+
+        :stability: experimental
+        '''
+        result = self._values.get("namespace_name")
+        assert result is not None, "Required property 'namespace_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def table_bucket(self) -> ITableBucket:
+        '''(experimental) The table bucket this namespace belongs to.
+
+        :stability: experimental
+        '''
+        result = self._values.get("table_bucket")
+        assert result is not None, "Required property 'table_bucket' is missing"
+        return typing.cast(ITableBucket, result)
+
+    @builtins.property
+    def removal_policy(self) -> typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy]:
+        '''(experimental) Policy to apply when the policy is removed from this stack.
+
+        :default: RemovalPolicy.DESTROY
+
+        :stability: experimental
+        '''
+        result = self._values.get("removal_policy")
+        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy], 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 "NamespaceProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="@aws-cdk/aws-s3tables-alpha.OpenTableFormat")
+class OpenTableFormat(enum.Enum):
+    '''(experimental) Supported open table formats.
+
+    :stability: experimental
+    '''
+
+    ICEBERG = "ICEBERG"
+    '''(experimental) Apache Iceberg table format.
+
+    :stability: experimental
+    '''
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.SchemaFieldProperty",
+    jsii_struct_bases=[],
+    name_mapping={"name": "name", "type": "type", "required": "required"},
+)
+class SchemaFieldProperty:
+    def __init__(
+        self,
+        *,
+        name: builtins.str,
+        type: builtins.str,
+        required: typing.Optional[builtins.bool] = None,
+    ) -> None:
+        '''(experimental) Contains details about a schema field.
+
+        :param name: (experimental) The name of the field.
+        :param type: (experimental) The field type. S3 Tables supports all Apache Iceberg primitive types. For more information, see the `Apache Iceberg documentation <https://docs.aws.amazon.com/https://iceberg.apache.org/spec/#primitive-types>`_.
+        :param required: (experimental) A Boolean value that specifies whether values are required for each row in this field. By default, this is ``false`` and null values are allowed in the field. If this is ``true``, the field does not allow null values. Default: false
+
+        :stability: experimental
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk.aws_s3tables_alpha as s3tables_alpha
+            
+            schema_field_property = s3tables_alpha.SchemaFieldProperty(
+                name="name",
+                type="type",
+            
+                # the properties below are optional
+                required=False
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__798c061a7214691172814263e161286845f9f56262e641ae55c93d363ce227c1)
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument type", value=type, expected_type=type_hints["type"])
+            check_type(argname="argument required", value=required, expected_type=type_hints["required"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "name": name,
+            "type": type,
+        }
+        if required is not None:
+            self._values["required"] = required
+
+    @builtins.property
+    def name(self) -> builtins.str:
+        '''(experimental) The name of the field.
+
+        :stability: experimental
+        '''
+        result = self._values.get("name")
+        assert result is not None, "Required property 'name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def type(self) -> builtins.str:
+        '''(experimental) The field type.
+
+        S3 Tables supports all Apache Iceberg primitive types. For more information, see the `Apache Iceberg documentation <https://docs.aws.amazon.com/https://iceberg.apache.org/spec/#primitive-types>`_.
+
+        :stability: experimental
+        '''
+        result = self._values.get("type")
+        assert result is not None, "Required property 'type' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def required(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) A Boolean value that specifies whether values are required for each row in this field.
+
+        By default, this is ``false`` and null values are allowed in the field. If this is ``true``, the field does not allow null values.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("required")
+        return typing.cast(typing.Optional[builtins.bool], 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 "SchemaFieldProperty(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.SnapshotManagementProperty",
+    jsii_struct_bases=[],
+    name_mapping={
+        "max_snapshot_age_hours": "maxSnapshotAgeHours",
+        "min_snapshots_to_keep": "minSnapshotsToKeep",
+        "status": "status",
+    },
+)
+class SnapshotManagementProperty:
+    def __init__(
+        self,
+        *,
+        max_snapshot_age_hours: typing.Optional[jsii.Number] = None,
+        min_snapshots_to_keep: typing.Optional[jsii.Number] = None,
+        status: typing.Optional["Status"] = None,
+    ) -> None:
+        '''(experimental) Contains details about the snapshot management settings for an Iceberg table.
+
+        A snapshot is expired when it exceeds MinSnapshotsToKeep and MaxSnapshotAgeHours.
+
+        :param max_snapshot_age_hours: (experimental) The maximum age of a snapshot before it can be expired. Default: - No maximum age
+        :param min_snapshots_to_keep: (experimental) The minimum number of snapshots to keep. Default: - No minimum number
+        :param status: (experimental) Indicates whether the SnapshotManagement maintenance action is enabled. Default: - Not specified
+
+        :default: - No snapshot management settings
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            # Build a table
+            sample_table = Table(scope, "ExampleTable",
+                table_name="example_table",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                without_metadata=True
+            )
+            
+            # Build a table with an Iceberg Schema
+            sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+                table_name="example_table_with_schema",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                iceberg_metadata=IcebergMetadataProperty(
+                    iceberg_schema=IcebergSchemaProperty(
+                        schema_field_list=[SchemaFieldProperty(
+                            name="id",
+                            type="int",
+                            required=True
+                        ), SchemaFieldProperty(
+                            name="name",
+                            type="string"
+                        )
+                        ]
+                    )
+                ),
+                compaction=CompactionProperty(
+                    status=Status.ENABLED,
+                    target_file_size_mb=128
+                ),
+                snapshot_management=SnapshotManagementProperty(
+                    status=Status.ENABLED,
+                    max_snapshot_age_hours=48,
+                    min_snapshots_to_keep=5
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__74aebe9bead3fb2bce88d441c25d815202759baedd02c817c6e08d2e1dfad2b2)
+            check_type(argname="argument max_snapshot_age_hours", value=max_snapshot_age_hours, expected_type=type_hints["max_snapshot_age_hours"])
+            check_type(argname="argument min_snapshots_to_keep", value=min_snapshots_to_keep, expected_type=type_hints["min_snapshots_to_keep"])
+            check_type(argname="argument status", value=status, expected_type=type_hints["status"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if max_snapshot_age_hours is not None:
+            self._values["max_snapshot_age_hours"] = max_snapshot_age_hours
+        if min_snapshots_to_keep is not None:
+            self._values["min_snapshots_to_keep"] = min_snapshots_to_keep
+        if status is not None:
+            self._values["status"] = status
+
+    @builtins.property
+    def max_snapshot_age_hours(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) The maximum age of a snapshot before it can be expired.
+
+        :default: - No maximum age
+
+        :stability: experimental
+        '''
+        result = self._values.get("max_snapshot_age_hours")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def min_snapshots_to_keep(self) -> typing.Optional[jsii.Number]:
+        '''(experimental) The minimum number of snapshots to keep.
+
+        :default: - No minimum number
+
+        :stability: experimental
+        '''
+        result = self._values.get("min_snapshots_to_keep")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def status(self) -> typing.Optional["Status"]:
+        '''(experimental) Indicates whether the SnapshotManagement maintenance action is enabled.
+
+        :default: - Not specified
+
+        :stability: experimental
+        '''
+        result = self._values.get("status")
+        return typing.cast(typing.Optional["Status"], 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 "SnapshotManagementProperty(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="@aws-cdk/aws-s3tables-alpha.Status")
+class Status(enum.Enum):
+    '''(experimental) Status values for maintenance actions.
+
+    :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        # Build a table
+        sample_table = Table(scope, "ExampleTable",
+            table_name="example_table",
+            namespace=namespace,
+            open_table_format=OpenTableFormat.ICEBERG,
+            without_metadata=True
+        )
+        
+        # Build a table with an Iceberg Schema
+        sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+            table_name="example_table_with_schema",
+            namespace=namespace,
+            open_table_format=OpenTableFormat.ICEBERG,
+            iceberg_metadata=IcebergMetadataProperty(
+                iceberg_schema=IcebergSchemaProperty(
+                    schema_field_list=[SchemaFieldProperty(
+                        name="id",
+                        type="int",
+                        required=True
+                    ), SchemaFieldProperty(
+                        name="name",
+                        type="string"
+                    )
+                    ]
+                )
+            ),
+            compaction=CompactionProperty(
+                status=Status.ENABLED,
+                target_file_size_mb=128
+            ),
+            snapshot_management=SnapshotManagementProperty(
+                status=Status.ENABLED,
+                max_snapshot_age_hours=48,
+                min_snapshots_to_keep=5
+            )
+        )
+    '''
+
+    ENABLED = "ENABLED"
+    '''(experimental) Enable the maintenance action.
+
+    :stability: experimental
+    '''
+    DISABLED = "DISABLED"
+    '''(experimental) Disable the maintenance action.
+
+    :stability: experimental
+    '''
+
+
+@jsii.implements(ITable)
+class Table(
+    _aws_cdk_ceddda9d.Resource,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="@aws-cdk/aws-s3tables-alpha.Table",
+):
+    '''(experimental) An S3 Table with helpers.
+
+    :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        # Build a table
+        sample_table = Table(scope, "ExampleTable",
+            table_name="example_table",
+            namespace=namespace,
+            open_table_format=OpenTableFormat.ICEBERG,
+            without_metadata=True
+        )
+        
+        # Build a table with an Iceberg Schema
+        sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+            table_name="example_table_with_schema",
+            namespace=namespace,
+            open_table_format=OpenTableFormat.ICEBERG,
+            iceberg_metadata=IcebergMetadataProperty(
+                iceberg_schema=IcebergSchemaProperty(
+                    schema_field_list=[SchemaFieldProperty(
+                        name="id",
+                        type="int",
+                        required=True
+                    ), SchemaFieldProperty(
+                        name="name",
+                        type="string"
+                    )
+                    ]
+                )
+            ),
+            compaction=CompactionProperty(
+                status=Status.ENABLED,
+                target_file_size_mb=128
+            ),
+            snapshot_management=SnapshotManagementProperty(
+                status=Status.ENABLED,
+                max_snapshot_age_hours=48,
+                min_snapshots_to_keep=5
+            )
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        namespace: INamespace,
+        open_table_format: OpenTableFormat,
+        table_name: builtins.str,
+        compaction: typing.Optional[typing.Union[CompactionProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+        iceberg_metadata: typing.Optional[typing.Union[IcebergMetadataProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+        removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+        snapshot_management: typing.Optional[typing.Union[SnapshotManagementProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+        without_metadata: typing.Optional[builtins.bool] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param namespace: (experimental) The namespace under which this table is created.
+        :param open_table_format: (experimental) Format of this table. Currently, the only supported value is OpenTableFormat.ICEBERG.
+        :param table_name: (experimental) Name of this table, unique within the namespace.
+        :param compaction: (experimental) Settings governing the Compaction maintenance action. Default: Amazon S3 selects the best compaction strategy based on your table sort order.
+        :param iceberg_metadata: (experimental) Contains details about the metadata for an Iceberg table. Default: table is created without any metadata
+        :param removal_policy: (experimental) Controls what happens to this table it it stoped being managed by cloudformation. Default: RETAIN
+        :param snapshot_management: (experimental) Contains details about the snapshot management settings for an Iceberg table. Default: enabled: MinimumSnapshots is 1 by default and MaximumSnapshotAge is 120 hours by default.
+        :param without_metadata: (experimental) If true, indicates that you don't want to specify a schema for the table. This property is mutually exclusive to 'IcebergMetadata'. Default: false
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__9e5378cdcc21935af950b3c144ea6d1e345b4c98cccbf5fe2a92dff410ed06cf)
+            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 = TableProps(
+            namespace=namespace,
+            open_table_format=open_table_format,
+            table_name=table_name,
+            compaction=compaction,
+            iceberg_metadata=iceberg_metadata,
+            removal_policy=removal_policy,
+            snapshot_management=snapshot_management,
+            without_metadata=without_metadata,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="fromTableAttributes")
+    @builtins.classmethod
+    def from_table_attributes(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        table_arn: builtins.str,
+        table_name: builtins.str,
+    ) -> ITable:
+        '''(experimental) Defines a Table construct that represents an external table.
+
+        :param scope: The parent creating construct (usually ``this``).
+        :param id: The construct's name.
+        :param table_arn: (experimental) The table's ARN.
+        :param table_name: (experimental) Name of this table.
+
+        :stability: experimental
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c92fbe73fcedcf34bbbc9a2359a274432437ec47317161e4c88ea9d209155ffd)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        attrs = TableAttributes(table_arn=table_arn, table_name=table_name)
+
+        return typing.cast(ITable, jsii.sinvoke(cls, "fromTableAttributes", [scope, id, attrs]))
+
+    @jsii.member(jsii_name="validateTableName")
+    @builtins.classmethod
+    def validate_table_name(cls, table_name: builtins.str) -> None:
+        '''(experimental) See https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets-naming.html.
+
+        :param table_name: Name of the table.
+
+        :stability: experimental
+        :throws: UnscopedValidationError if any naming errors are detected
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__536e137c7e7454507b9ec796514d014c3913e8c528dfeba351b5e0e36ba8e228)
+            check_type(argname="argument table_name", value=table_name, expected_type=type_hints["table_name"])
+        return typing.cast(None, jsii.sinvoke(cls, "validateTableName", [table_name]))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''(experimental) Uniquely identifies this class.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
+    @builtins.property
+    @jsii.member(jsii_name="namespace")
+    def namespace(self) -> INamespace:
+        '''(experimental) The namespace containing this table.
+
+        :stability: experimental
+        '''
+        return typing.cast(INamespace, jsii.get(self, "namespace"))
+
+    @builtins.property
+    @jsii.member(jsii_name="tableArn")
+    def table_arn(self) -> builtins.str:
+        '''(experimental) The unique Amazon Resource Name (arn) of this table.
+
+        :stability: experimental
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "tableArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="tableName")
+    def table_name(self) -> builtins.str:
+        '''(experimental) The name of this table.
 
         :stability: experimental
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__853d3e698d103ae1fe304d2239745ee798278fcd22f673c7ae8e9b33884c90a9)
-            check_type(argname="argument identity", value=identity, expected_type=type_hints["identity"])
-            check_type(argname="argument table_id", value=table_id, expected_type=type_hints["table_id"])
-        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantRead", [identity, table_id]))
+        return typing.cast(builtins.str, jsii.get(self, "tableName"))
 
-    @jsii.member(jsii_name="grantReadWrite")
-    def grant_read_write(
-        self,
-        identity: _aws_cdk_aws_iam_ceddda9d.IGrantable,
-        table_id: builtins.str,
-    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
-        '''(experimental) Grant read and write permissions for this table bucket and its tables to an IAM principal (Role/Group/User).
 
-        If encryption is used, permission to use the key to encrypt/decrypt the contents
-        of the bucket will also be granted to the same principal.
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.TableAttributes",
+    jsii_struct_bases=[],
+    name_mapping={"table_arn": "tableArn", "table_name": "tableName"},
+)
+class TableAttributes:
+    def __init__(self, *, table_arn: builtins.str, table_name: builtins.str) -> None:
+        '''(experimental) A reference to a table outside this stack.
 
-        :param identity: The principal to allow read and write permissions to.
-        :param table_id: Allow the permissions to all tables using '*' or to single table by its unique ID.
+        The tableName, region, and account can be provided explicitly
+        or will be inferred from the tableArn
+
+        :param table_arn: (experimental) The table's ARN.
+        :param table_name: (experimental) Name of this table.
 
         :stability: experimental
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            import aws_cdk.aws_s3tables_alpha as s3tables_alpha
+            
+            table_attributes = s3tables_alpha.TableAttributes(
+                table_arn="tableArn",
+                table_name="tableName"
+            )
         '''
         if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__1c9eb5186509f26b2c015223d6e2614c16cc34d5c2608ca3903b133360e23990)
-            check_type(argname="argument identity", value=identity, expected_type=type_hints["identity"])
-            check_type(argname="argument table_id", value=table_id, expected_type=type_hints["table_id"])
-        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantReadWrite", [identity, table_id]))
+            type_hints = typing.get_type_hints(_typecheckingstub__20a648b98b2aa2a4eec0f744feac0d8ec3ee06e18fb2a623e889d224bf8fec03)
+            check_type(argname="argument table_arn", value=table_arn, expected_type=type_hints["table_arn"])
+            check_type(argname="argument table_name", value=table_name, expected_type=type_hints["table_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "table_arn": table_arn,
+            "table_name": table_name,
+        }
 
-    @jsii.member(jsii_name="grantWrite")
-    def grant_write(
-        self,
-        identity: _aws_cdk_aws_iam_ceddda9d.IGrantable,
-        table_id: builtins.str,
-    ) -> _aws_cdk_aws_iam_ceddda9d.Grant:
-        '''(experimental) Grant write permissions for this table bucket and its tables to an IAM principal (Role/Group/User).
+    @builtins.property
+    def table_arn(self) -> builtins.str:
+        '''(experimental) The table's ARN.
 
-        If encryption is used, permission to use the key to encrypt the contents
-        of the bucket will also be granted to the same principal.
+        :stability: experimental
+        '''
+        result = self._values.get("table_arn")
+        assert result is not None, "Required property 'table_arn' is missing"
+        return typing.cast(builtins.str, result)
 
-        :param identity: The principal to allow write permissions to.
-        :param table_id: Allow the permissions to all tables using '*' or to single table by its unique ID.
+    @builtins.property
+    def table_name(self) -> builtins.str:
+        '''(experimental) Name of this table.
 
         :stability: experimental
         '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__65fa831e505e76e1fe23a8a8d8ce97bb97ebff683edbf67f37020df64c040fdb)
-            check_type(argname="argument identity", value=identity, expected_type=type_hints["identity"])
-            check_type(argname="argument table_id", value=table_id, expected_type=type_hints["table_id"])
-        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Grant, jsii.invoke(self, "grantWrite", [identity, table_id]))
+        result = self._values.get("table_name")
+        assert result is not None, "Required property 'table_name' is missing"
+        return typing.cast(builtins.str, result)
 
-# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
-typing.cast(typing.Any, ITableBucket).__jsii_proxy_class__ = lambda : _ITableBucketProxy
+    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 "TableAttributes(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
 
 
 @jsii.implements(ITableBucket)
@@ -1317,6 +2632,220 @@ class TableBucketProps:
         )
 
 
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-s3tables-alpha.TableProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "namespace": "namespace",
+        "open_table_format": "openTableFormat",
+        "table_name": "tableName",
+        "compaction": "compaction",
+        "iceberg_metadata": "icebergMetadata",
+        "removal_policy": "removalPolicy",
+        "snapshot_management": "snapshotManagement",
+        "without_metadata": "withoutMetadata",
+    },
+)
+class TableProps:
+    def __init__(
+        self,
+        *,
+        namespace: INamespace,
+        open_table_format: OpenTableFormat,
+        table_name: builtins.str,
+        compaction: typing.Optional[typing.Union[CompactionProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+        iceberg_metadata: typing.Optional[typing.Union[IcebergMetadataProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+        removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+        snapshot_management: typing.Optional[typing.Union[SnapshotManagementProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+        without_metadata: typing.Optional[builtins.bool] = None,
+    ) -> None:
+        '''(experimental) Properties for creating a new S3 Table.
+
+        :param namespace: (experimental) The namespace under which this table is created.
+        :param open_table_format: (experimental) Format of this table. Currently, the only supported value is OpenTableFormat.ICEBERG.
+        :param table_name: (experimental) Name of this table, unique within the namespace.
+        :param compaction: (experimental) Settings governing the Compaction maintenance action. Default: Amazon S3 selects the best compaction strategy based on your table sort order.
+        :param iceberg_metadata: (experimental) Contains details about the metadata for an Iceberg table. Default: table is created without any metadata
+        :param removal_policy: (experimental) Controls what happens to this table it it stoped being managed by cloudformation. Default: RETAIN
+        :param snapshot_management: (experimental) Contains details about the snapshot management settings for an Iceberg table. Default: enabled: MinimumSnapshots is 1 by default and MaximumSnapshotAge is 120 hours by default.
+        :param without_metadata: (experimental) If true, indicates that you don't want to specify a schema for the table. This property is mutually exclusive to 'IcebergMetadata'. Default: false
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            # Build a table
+            sample_table = Table(scope, "ExampleTable",
+                table_name="example_table",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                without_metadata=True
+            )
+            
+            # Build a table with an Iceberg Schema
+            sample_table_with_schema = Table(scope, "ExampleSchemaTable",
+                table_name="example_table_with_schema",
+                namespace=namespace,
+                open_table_format=OpenTableFormat.ICEBERG,
+                iceberg_metadata=IcebergMetadataProperty(
+                    iceberg_schema=IcebergSchemaProperty(
+                        schema_field_list=[SchemaFieldProperty(
+                            name="id",
+                            type="int",
+                            required=True
+                        ), SchemaFieldProperty(
+                            name="name",
+                            type="string"
+                        )
+                        ]
+                    )
+                ),
+                compaction=CompactionProperty(
+                    status=Status.ENABLED,
+                    target_file_size_mb=128
+                ),
+                snapshot_management=SnapshotManagementProperty(
+                    status=Status.ENABLED,
+                    max_snapshot_age_hours=48,
+                    min_snapshots_to_keep=5
+                )
+            )
+        '''
+        if isinstance(compaction, dict):
+            compaction = CompactionProperty(**compaction)
+        if isinstance(iceberg_metadata, dict):
+            iceberg_metadata = IcebergMetadataProperty(**iceberg_metadata)
+        if isinstance(snapshot_management, dict):
+            snapshot_management = SnapshotManagementProperty(**snapshot_management)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__adbbcc05d3dc39dfd296a872f006be429c733d0afc6f602e57bd2bede716f05e)
+            check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
+            check_type(argname="argument open_table_format", value=open_table_format, expected_type=type_hints["open_table_format"])
+            check_type(argname="argument table_name", value=table_name, expected_type=type_hints["table_name"])
+            check_type(argname="argument compaction", value=compaction, expected_type=type_hints["compaction"])
+            check_type(argname="argument iceberg_metadata", value=iceberg_metadata, expected_type=type_hints["iceberg_metadata"])
+            check_type(argname="argument removal_policy", value=removal_policy, expected_type=type_hints["removal_policy"])
+            check_type(argname="argument snapshot_management", value=snapshot_management, expected_type=type_hints["snapshot_management"])
+            check_type(argname="argument without_metadata", value=without_metadata, expected_type=type_hints["without_metadata"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "namespace": namespace,
+            "open_table_format": open_table_format,
+            "table_name": table_name,
+        }
+        if compaction is not None:
+            self._values["compaction"] = compaction
+        if iceberg_metadata is not None:
+            self._values["iceberg_metadata"] = iceberg_metadata
+        if removal_policy is not None:
+            self._values["removal_policy"] = removal_policy
+        if snapshot_management is not None:
+            self._values["snapshot_management"] = snapshot_management
+        if without_metadata is not None:
+            self._values["without_metadata"] = without_metadata
+
+    @builtins.property
+    def namespace(self) -> INamespace:
+        '''(experimental) The namespace under which this table is created.
+
+        :stability: experimental
+        '''
+        result = self._values.get("namespace")
+        assert result is not None, "Required property 'namespace' is missing"
+        return typing.cast(INamespace, result)
+
+    @builtins.property
+    def open_table_format(self) -> OpenTableFormat:
+        '''(experimental) Format of this table.
+
+        Currently, the only supported value is OpenTableFormat.ICEBERG.
+
+        :stability: experimental
+        '''
+        result = self._values.get("open_table_format")
+        assert result is not None, "Required property 'open_table_format' is missing"
+        return typing.cast(OpenTableFormat, result)
+
+    @builtins.property
+    def table_name(self) -> builtins.str:
+        '''(experimental) Name of this table, unique within the namespace.
+
+        :stability: experimental
+        '''
+        result = self._values.get("table_name")
+        assert result is not None, "Required property 'table_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def compaction(self) -> typing.Optional[CompactionProperty]:
+        '''(experimental) Settings governing the Compaction maintenance action.
+
+        :default: Amazon S3 selects the best compaction strategy based on your table sort order.
+
+        :see: https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-maintenance.html
+        :stability: experimental
+        '''
+        result = self._values.get("compaction")
+        return typing.cast(typing.Optional[CompactionProperty], result)
+
+    @builtins.property
+    def iceberg_metadata(self) -> typing.Optional[IcebergMetadataProperty]:
+        '''(experimental) Contains details about the metadata for an Iceberg table.
+
+        :default: table is created without any metadata
+
+        :stability: experimental
+        '''
+        result = self._values.get("iceberg_metadata")
+        return typing.cast(typing.Optional[IcebergMetadataProperty], result)
+
+    @builtins.property
+    def removal_policy(self) -> typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy]:
+        '''(experimental) Controls what happens to this table it it stoped being managed by cloudformation.
+
+        :default: RETAIN
+
+        :stability: experimental
+        '''
+        result = self._values.get("removal_policy")
+        return typing.cast(typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy], result)
+
+    @builtins.property
+    def snapshot_management(self) -> typing.Optional[SnapshotManagementProperty]:
+        '''(experimental) Contains details about the snapshot management settings for an Iceberg table.
+
+        :default: enabled: MinimumSnapshots is 1 by default and MaximumSnapshotAge is 120 hours by default.
+
+        :stability: experimental
+        '''
+        result = self._values.get("snapshot_management")
+        return typing.cast(typing.Optional[SnapshotManagementProperty], result)
+
+    @builtins.property
+    def without_metadata(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) If true, indicates that you don't want to specify a schema for the table.
+
+        This property is mutually exclusive to 'IcebergMetadata'.
+
+        :default: false
+
+        :stability: experimental
+        '''
+        result = self._values.get("without_metadata")
+        return typing.cast(typing.Optional[builtins.bool], 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 "TableProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="@aws-cdk/aws-s3tables-alpha.UnreferencedFileRemoval",
     jsii_struct_bases=[],
@@ -1457,19 +2986,42 @@ class UnreferencedFileRemovalStatus(enum.Enum):
 
 
 __all__ = [
+    "CompactionProperty",
+    "INamespace",
+    "ITable",
     "ITableBucket",
+    "IcebergMetadataProperty",
+    "IcebergSchemaProperty",
+    "Namespace",
+    "NamespaceAttributes",
+    "NamespaceProps",
+    "OpenTableFormat",
+    "SchemaFieldProperty",
+    "SnapshotManagementProperty",
+    "Status",
+    "Table",
+    "TableAttributes",
     "TableBucket",
     "TableBucketAttributes",
     "TableBucketEncryption",
     "TableBucketPolicy",
     "TableBucketPolicyProps",
     "TableBucketProps",
+    "TableProps",
     "UnreferencedFileRemoval",
     "UnreferencedFileRemovalStatus",
 ]
 
 publication.publish()
 
+def _typecheckingstub__ea606cde59917b73fdb198d73eabdbbe686fdbd73e01ef72284a9061ea612d80(
+    *,
+    status: Status,
+    target_file_size_mb: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a7c10542c60e15926bb4ef59925c4f6c0878400e041897780edddaa65054d627(
     statement: _aws_cdk_aws_iam_ceddda9d.PolicyStatement,
 ) -> None:
@@ -1497,6 +3049,122 @@ def _typecheckingstub__65fa831e505e76e1fe23a8a8d8ce97bb97ebff683edbf67f37020df64
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__f8230e6a4eadd2193ba7389b1a23bde451e68a07c19bcda56cba1c321d75d5f0(
+    *,
+    iceberg_schema: typing.Union[IcebergSchemaProperty, typing.Dict[builtins.str, typing.Any]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__f4da2961c1ead632b855491f63cf76c4886c0e7a3d1795c1533655124a5dccb6(
+    *,
+    schema_field_list: typing.Sequence[typing.Union[SchemaFieldProperty, typing.Dict[builtins.str, typing.Any]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ea3444f2b1f25cee0bac27bf1e4c044f18ded5f025356448c35a47f4611915d5(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    namespace_name: builtins.str,
+    table_bucket: ITableBucket,
+    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__429e6100662356607de36bc4f09397c07482d4becdff99cdf1257c1b95547276(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    namespace_name: builtins.str,
+    table_bucket: ITableBucket,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__4a07351eb257958d2290e548252c46a7c8963c7bc2f700e83671f819e4b7dbd5(
+    namespace_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__8f79f8c2998fe357462fbff82a75e82ed3236dd34caffcf6f6267cffcdda3275(
+    *,
+    namespace_name: builtins.str,
+    table_bucket: ITableBucket,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__fd18f87a98f23ccaea0f0c36db6b294de2ffbbb509594c9bfa49f26b6b0d0e7a(
+    *,
+    namespace_name: builtins.str,
+    table_bucket: ITableBucket,
+    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__798c061a7214691172814263e161286845f9f56262e641ae55c93d363ce227c1(
+    *,
+    name: builtins.str,
+    type: builtins.str,
+    required: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__74aebe9bead3fb2bce88d441c25d815202759baedd02c817c6e08d2e1dfad2b2(
+    *,
+    max_snapshot_age_hours: typing.Optional[jsii.Number] = None,
+    min_snapshots_to_keep: typing.Optional[jsii.Number] = None,
+    status: typing.Optional[Status] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__9e5378cdcc21935af950b3c144ea6d1e345b4c98cccbf5fe2a92dff410ed06cf(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    namespace: INamespace,
+    open_table_format: OpenTableFormat,
+    table_name: builtins.str,
+    compaction: typing.Optional[typing.Union[CompactionProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+    iceberg_metadata: typing.Optional[typing.Union[IcebergMetadataProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+    snapshot_management: typing.Optional[typing.Union[SnapshotManagementProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+    without_metadata: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__c92fbe73fcedcf34bbbc9a2359a274432437ec47317161e4c88ea9d209155ffd(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    table_arn: builtins.str,
+    table_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__536e137c7e7454507b9ec796514d014c3913e8c528dfeba351b5e0e36ba8e228(
+    table_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__20a648b98b2aa2a4eec0f744feac0d8ec3ee06e18fb2a623e889d224bf8fec03(
+    *,
+    table_arn: builtins.str,
+    table_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c8d9c0bf5c954c2a6797301b7dc6cb8abd812336f3507addc92f72b805ec0a1e(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -1616,6 +3284,20 @@ def _typecheckingstub__aa14ccf904c2576c446af7122d6335d3a92b012274a231120ab28c942
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__adbbcc05d3dc39dfd296a872f006be429c733d0afc6f602e57bd2bede716f05e(
+    *,
+    namespace: INamespace,
+    open_table_format: OpenTableFormat,
+    table_name: builtins.str,
+    compaction: typing.Optional[typing.Union[CompactionProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+    iceberg_metadata: typing.Optional[typing.Union[IcebergMetadataProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+    removal_policy: typing.Optional[_aws_cdk_ceddda9d.RemovalPolicy] = None,
+    snapshot_management: typing.Optional[typing.Union[SnapshotManagementProperty, typing.Dict[builtins.str, typing.Any]]] = None,
+    without_metadata: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b3c9fa2e0832ae26e721328d6c201e9e86774721d68903a6414d69d8a77a5675(
     *,
     noncurrent_days: typing.Optional[jsii.Number] = None,