aws-cdk-lib 2.90.0__py3-none-any.whl → 2.92.0__py3-none-any.whl

aws_cdk/aws_glue/__init__.py

@@ -78,7 +78,9 @@ class CfnClassifier(
         cfn_classifier = glue.CfnClassifier(self, "MyCfnClassifier",
             csv_classifier=glue.CfnClassifier.CsvClassifierProperty(
                 allow_single_column=False,
+                contains_custom_datatype=["containsCustomDatatype"],
                 contains_header="containsHeader",
+                custom_datatype_configured=False,
                 delimiter="delimiter",
                 disable_value_trimming=False,
                 header=["header"],
@@ -260,7 +262,9 @@ class CfnClassifier(
         jsii_struct_bases=[],
         name_mapping={
             "allow_single_column": "allowSingleColumn",
+            "contains_custom_datatype": "containsCustomDatatype",
             "contains_header": "containsHeader",
+            "custom_datatype_configured": "customDatatypeConfigured",
             "delimiter": "delimiter",
             "disable_value_trimming": "disableValueTrimming",
             "header": "header",
@@ -273,7 +277,9 @@ class CfnClassifier(
             self,
             *,
             allow_single_column: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            contains_custom_datatype: typing.Optional[typing.Sequence[builtins.str]] = None,
             contains_header: typing.Optional[builtins.str] = None,
+            custom_datatype_configured: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             delimiter: typing.Optional[builtins.str] = None,
             disable_value_trimming: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             header: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -283,7 +289,9 @@ class CfnClassifier(
             '''A classifier for custom ``CSV`` content.
 
             :param allow_single_column: Enables the processing of files that contain only one column.
+            :param contains_custom_datatype: 
             :param contains_header: Indicates whether the CSV file contains a header. A value of ``UNKNOWN`` specifies that the classifier will detect whether the CSV file contains headings. A value of ``PRESENT`` specifies that the CSV file contains headings. A value of ``ABSENT`` specifies that the CSV file does not contain headings.
+            :param custom_datatype_configured: 
             :param delimiter: A custom symbol to denote what separates each column entry in the row.
             :param disable_value_trimming: Specifies not to trim values before identifying the type of column values. The default value is ``true`` .
             :param header: A list of strings representing column names.
@@ -301,7 +309,9 @@ class CfnClassifier(
                 
                 csv_classifier_property = glue.CfnClassifier.CsvClassifierProperty(
                     allow_single_column=False,
+                    contains_custom_datatype=["containsCustomDatatype"],
                     contains_header="containsHeader",
+                    custom_datatype_configured=False,
                     delimiter="delimiter",
                     disable_value_trimming=False,
                     header=["header"],
@@ -312,7 +322,9 @@ class CfnClassifier(
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__dd722ed29ebf9e1505b4d21b5e95cb0f8d4e96b052ed45a497086e92f8d1eb4c)
                 check_type(argname="argument allow_single_column", value=allow_single_column, expected_type=type_hints["allow_single_column"])
+                check_type(argname="argument contains_custom_datatype", value=contains_custom_datatype, expected_type=type_hints["contains_custom_datatype"])
                 check_type(argname="argument contains_header", value=contains_header, expected_type=type_hints["contains_header"])
+                check_type(argname="argument custom_datatype_configured", value=custom_datatype_configured, expected_type=type_hints["custom_datatype_configured"])
                 check_type(argname="argument delimiter", value=delimiter, expected_type=type_hints["delimiter"])
                 check_type(argname="argument disable_value_trimming", value=disable_value_trimming, expected_type=type_hints["disable_value_trimming"])
                 check_type(argname="argument header", value=header, expected_type=type_hints["header"])
@@ -321,8 +333,12 @@ class CfnClassifier(
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if allow_single_column is not None:
                 self._values["allow_single_column"] = allow_single_column
+            if contains_custom_datatype is not None:
+                self._values["contains_custom_datatype"] = contains_custom_datatype
             if contains_header is not None:
                 self._values["contains_header"] = contains_header
+            if custom_datatype_configured is not None:
+                self._values["custom_datatype_configured"] = custom_datatype_configured
             if delimiter is not None:
                 self._values["delimiter"] = delimiter
             if disable_value_trimming is not None:
@@ -345,6 +361,16 @@ class CfnClassifier(
             result = self._values.get("allow_single_column")
             return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
 
+        @builtins.property
+        def contains_custom_datatype(
+            self,
+        ) -> typing.Optional[typing.List[builtins.str]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-classifier-csvclassifier.html#cfn-glue-classifier-csvclassifier-containscustomdatatype
+            '''
+            result = self._values.get("contains_custom_datatype")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
         @builtins.property
         def contains_header(self) -> typing.Optional[builtins.str]:
             '''Indicates whether the CSV file contains a header.
@@ -360,6 +386,16 @@ class CfnClassifier(
             result = self._values.get("contains_header")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def custom_datatype_configured(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-classifier-csvclassifier.html#cfn-glue-classifier-csvclassifier-customdatatypeconfigured
+            '''
+            result = self._values.get("custom_datatype_configured")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
         @builtins.property
         def delimiter(self) -> typing.Optional[builtins.str]:
             '''A custom symbol to denote what separates each column entry in the row.
@@ -742,7 +778,9 @@ class CfnClassifierProps:
             cfn_classifier_props = glue.CfnClassifierProps(
                 csv_classifier=glue.CfnClassifier.CsvClassifierProperty(
                     allow_single_column=False,
+                    contains_custom_datatype=["containsCustomDatatype"],
                     contains_header="containsHeader",
+                    custom_datatype_configured=False,
                     delimiter="delimiter",
                     disable_value_trimming=False,
                     header=["header"],
@@ -1399,6 +1437,12 @@ class CfnCrawler(
                 dynamo_db_targets=[glue.CfnCrawler.DynamoDBTargetProperty(
                     path="path"
                 )],
+                iceberg_targets=[glue.CfnCrawler.IcebergTargetProperty(
+                    connection_name="connectionName",
+                    exclusions=["exclusions"],
+                    maximum_traversal_depth=123,
+                    paths=["paths"]
+                )],
                 jdbc_targets=[glue.CfnCrawler.JdbcTargetProperty(
                     connection_name="connectionName",
                     exclusions=["exclusions"],
@@ -2024,6 +2068,106 @@ class CfnCrawler(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_glue.CfnCrawler.IcebergTargetProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "connection_name": "connectionName",
+            "exclusions": "exclusions",
+            "maximum_traversal_depth": "maximumTraversalDepth",
+            "paths": "paths",
+        },
+    )
+    class IcebergTargetProperty:
+        def __init__(
+            self,
+            *,
+            connection_name: typing.Optional[builtins.str] = None,
+            exclusions: typing.Optional[typing.Sequence[builtins.str]] = None,
+            maximum_traversal_depth: typing.Optional[jsii.Number] = None,
+            paths: typing.Optional[typing.Sequence[builtins.str]] = None,
+        ) -> None:
+            '''
+            :param connection_name: 
+            :param exclusions: 
+            :param maximum_traversal_depth: 
+            :param paths: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-icebergtarget.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_glue as glue
+                
+                iceberg_target_property = glue.CfnCrawler.IcebergTargetProperty(
+                    connection_name="connectionName",
+                    exclusions=["exclusions"],
+                    maximum_traversal_depth=123,
+                    paths=["paths"]
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__fc4d48721f48f2b8be2bdcc36b62b7559b104ac87185a032281e5b09d46901e3)
+                check_type(argname="argument connection_name", value=connection_name, expected_type=type_hints["connection_name"])
+                check_type(argname="argument exclusions", value=exclusions, expected_type=type_hints["exclusions"])
+                check_type(argname="argument maximum_traversal_depth", value=maximum_traversal_depth, expected_type=type_hints["maximum_traversal_depth"])
+                check_type(argname="argument paths", value=paths, expected_type=type_hints["paths"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if connection_name is not None:
+                self._values["connection_name"] = connection_name
+            if exclusions is not None:
+                self._values["exclusions"] = exclusions
+            if maximum_traversal_depth is not None:
+                self._values["maximum_traversal_depth"] = maximum_traversal_depth
+            if paths is not None:
+                self._values["paths"] = paths
+
+        @builtins.property
+        def connection_name(self) -> typing.Optional[builtins.str]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-icebergtarget.html#cfn-glue-crawler-icebergtarget-connectionname
+            '''
+            result = self._values.get("connection_name")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def exclusions(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-icebergtarget.html#cfn-glue-crawler-icebergtarget-exclusions
+            '''
+            result = self._values.get("exclusions")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def maximum_traversal_depth(self) -> typing.Optional[jsii.Number]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-icebergtarget.html#cfn-glue-crawler-icebergtarget-maximumtraversaldepth
+            '''
+            result = self._values.get("maximum_traversal_depth")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def paths(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-icebergtarget.html#cfn-glue-crawler-icebergtarget-paths
+            '''
+            result = self._values.get("paths")
+            return typing.cast(typing.Optional[typing.List[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 "IcebergTargetProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_glue.CfnCrawler.JdbcTargetProperty",
         jsii_struct_bases=[],
@@ -2544,6 +2688,7 @@ class CfnCrawler(
             "catalog_targets": "catalogTargets",
             "delta_targets": "deltaTargets",
             "dynamo_db_targets": "dynamoDbTargets",
+            "iceberg_targets": "icebergTargets",
             "jdbc_targets": "jdbcTargets",
             "mongo_db_targets": "mongoDbTargets",
             "s3_targets": "s3Targets",
@@ -2556,6 +2701,7 @@ class CfnCrawler(
             catalog_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCrawler.CatalogTargetProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             delta_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCrawler.DeltaTargetProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             dynamo_db_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCrawler.DynamoDBTargetProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+            iceberg_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCrawler.IcebergTargetProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             jdbc_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCrawler.JdbcTargetProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             mongo_db_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCrawler.MongoDBTargetProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             s3_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCrawler.S3TargetProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -2565,6 +2711,7 @@ class CfnCrawler(
             :param catalog_targets: Specifies AWS Glue Data Catalog targets.
             :param delta_targets: Specifies an array of Delta data store targets.
             :param dynamo_db_targets: Specifies Amazon DynamoDB targets.
+            :param iceberg_targets: 
             :param jdbc_targets: Specifies JDBC targets.
             :param mongo_db_targets: A list of Mongo DB targets.
             :param s3_targets: Specifies Amazon Simple Storage Service (Amazon S3) targets.
@@ -2595,6 +2742,12 @@ class CfnCrawler(
                     dynamo_db_targets=[glue.CfnCrawler.DynamoDBTargetProperty(
                         path="path"
                     )],
+                    iceberg_targets=[glue.CfnCrawler.IcebergTargetProperty(
+                        connection_name="connectionName",
+                        exclusions=["exclusions"],
+                        maximum_traversal_depth=123,
+                        paths=["paths"]
+                    )],
                     jdbc_targets=[glue.CfnCrawler.JdbcTargetProperty(
                         connection_name="connectionName",
                         exclusions=["exclusions"],
@@ -2619,6 +2772,7 @@ class CfnCrawler(
                 check_type(argname="argument catalog_targets", value=catalog_targets, expected_type=type_hints["catalog_targets"])
                 check_type(argname="argument delta_targets", value=delta_targets, expected_type=type_hints["delta_targets"])
                 check_type(argname="argument dynamo_db_targets", value=dynamo_db_targets, expected_type=type_hints["dynamo_db_targets"])
+                check_type(argname="argument iceberg_targets", value=iceberg_targets, expected_type=type_hints["iceberg_targets"])
                 check_type(argname="argument jdbc_targets", value=jdbc_targets, expected_type=type_hints["jdbc_targets"])
                 check_type(argname="argument mongo_db_targets", value=mongo_db_targets, expected_type=type_hints["mongo_db_targets"])
                 check_type(argname="argument s3_targets", value=s3_targets, expected_type=type_hints["s3_targets"])
@@ -2629,6 +2783,8 @@ class CfnCrawler(
                 self._values["delta_targets"] = delta_targets
             if dynamo_db_targets is not None:
                 self._values["dynamo_db_targets"] = dynamo_db_targets
+            if iceberg_targets is not None:
+                self._values["iceberg_targets"] = iceberg_targets
             if jdbc_targets is not None:
                 self._values["jdbc_targets"] = jdbc_targets
             if mongo_db_targets is not None:
@@ -2669,6 +2825,16 @@ class CfnCrawler(
             result = self._values.get("dynamo_db_targets")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCrawler.DynamoDBTargetProperty"]]]], result)
 
+        @builtins.property
+        def iceberg_targets(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCrawler.IcebergTargetProperty"]]]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-targets.html#cfn-glue-crawler-targets-icebergtargets
+            '''
+            result = self._values.get("iceberg_targets")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnCrawler.IcebergTargetProperty"]]]], result)
+
         @builtins.property
         def jdbc_targets(
             self,
@@ -2797,6 +2963,12 @@ class CfnCrawlerProps:
                     dynamo_db_targets=[glue.CfnCrawler.DynamoDBTargetProperty(
                         path="path"
                     )],
+                    iceberg_targets=[glue.CfnCrawler.IcebergTargetProperty(
+                        connection_name="connectionName",
+                        exclusions=["exclusions"],
+                        maximum_traversal_depth=123,
+                        paths=["paths"]
+                    )],
                     jdbc_targets=[glue.CfnCrawler.JdbcTargetProperty(
                         connection_name="connectionName",
                         exclusions=["exclusions"],
@@ -3942,7 +4114,8 @@ class CfnDatabase(
                 parameters=parameters,
                 target_database=glue.CfnDatabase.DatabaseIdentifierProperty(
                     catalog_id="catalogId",
-                    database_name="databaseName"
+                    database_name="databaseName",
+                    region="region"
                 )
             )
         )
@@ -4102,7 +4275,11 @@ class CfnDatabase(
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_glue.CfnDatabase.DatabaseIdentifierProperty",
         jsii_struct_bases=[],
-        name_mapping={"catalog_id": "catalogId", "database_name": "databaseName"},
+        name_mapping={
+            "catalog_id": "catalogId",
+            "database_name": "databaseName",
+            "region": "region",
+        },
     )
     class DatabaseIdentifierProperty:
         def __init__(
@@ -4110,11 +4287,13 @@ class CfnDatabase(
             *,
             catalog_id: typing.Optional[builtins.str] = None,
             database_name: typing.Optional[builtins.str] = None,
+            region: typing.Optional[builtins.str] = None,
         ) -> None:
             '''A structure that describes a target database for resource linking.
 
             :param catalog_id: The ID of the Data Catalog in which the database resides.
             :param database_name: The name of the catalog database.
+            :param region: 
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-database-databaseidentifier.html
             :exampleMetadata: fixture=_generated
@@ -4127,18 +4306,22 @@ class CfnDatabase(
                 
                 database_identifier_property = glue.CfnDatabase.DatabaseIdentifierProperty(
                     catalog_id="catalogId",
-                    database_name="databaseName"
+                    database_name="databaseName",
+                    region="region"
                 )
             '''
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__5e1e09205087e89c58802ef33b1c27bb5ad9de3db3e6419d7c72b490675f5e27)
                 check_type(argname="argument catalog_id", value=catalog_id, expected_type=type_hints["catalog_id"])
                 check_type(argname="argument database_name", value=database_name, expected_type=type_hints["database_name"])
+                check_type(argname="argument region", value=region, expected_type=type_hints["region"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if catalog_id is not None:
                 self._values["catalog_id"] = catalog_id
             if database_name is not None:
                 self._values["database_name"] = database_name
+            if region is not None:
+                self._values["region"] = region
 
         @builtins.property
         def catalog_id(self) -> typing.Optional[builtins.str]:
@@ -4158,6 +4341,14 @@ class CfnDatabase(
             result = self._values.get("database_name")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def region(self) -> typing.Optional[builtins.str]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-database-databaseidentifier.html#cfn-glue-database-databaseidentifier-region
+            '''
+            result = self._values.get("region")
+            return typing.cast(typing.Optional[builtins.str], result)
+
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -4232,7 +4423,8 @@ class CfnDatabase(
                     parameters=parameters,
                     target_database=glue.CfnDatabase.DatabaseIdentifierProperty(
                         catalog_id="catalogId",
-                        database_name="databaseName"
+                        database_name="databaseName",
+                        region="region"
                     )
                 )
             '''
@@ -4537,7 +4729,8 @@ class CfnDatabaseProps:
                     parameters=parameters,
                     target_database=glue.CfnDatabase.DatabaseIdentifierProperty(
                         catalog_id="catalogId",
-                        database_name="databaseName"
+                        database_name="databaseName",
+                        region="region"
                     )
                 )
             )
@@ -11032,10 +11225,19 @@ class CfnTable(
                 target_table=glue.CfnTable.TableIdentifierProperty(
                     catalog_id="catalogId",
                     database_name="databaseName",
-                    name="name"
+                    name="name",
+                    region="region"
                 ),
                 view_expanded_text="viewExpandedText",
                 view_original_text="viewOriginalText"
+            ),
+        
+            # the properties below are optional
+            open_table_format_input=glue.CfnTable.OpenTableFormatInputProperty(
+                iceberg_input=glue.CfnTable.IcebergInputProperty(
+                    metadata_operation="metadataOperation",
+                    version="version"
+                )
             )
         )
     '''
@@ -11048,6 +11250,7 @@ class CfnTable(
         catalog_id: builtins.str,
         database_name: builtins.str,
         table_input: typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.TableInputProperty", typing.Dict[builtins.str, typing.Any]]],
+        open_table_format_input: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.OpenTableFormatInputProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''
         :param scope: Scope in which this resource is defined.
@@ -11055,13 +11258,17 @@ class CfnTable(
         :param catalog_id: The ID of the Data Catalog in which to create the ``Table`` .
         :param database_name: The name of the database where the table metadata resides. For Hive compatibility, this must be all lowercase.
         :param table_input: A structure used to define a table.
+        :param open_table_format_input: 
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__63721068e81107cadbf3e418ec393de98f88a141604f2bb1044b5ae302e922ad)
             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 = CfnTableProps(
-            catalog_id=catalog_id, database_name=database_name, table_input=table_input
+            catalog_id=catalog_id,
+            database_name=database_name,
+            table_input=table_input,
+            open_table_format_input=open_table_format_input,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -11153,6 +11360,23 @@ class CfnTable(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "tableInput", value)
 
+    @builtins.property
+    @jsii.member(jsii_name="openTableFormatInput")
+    def open_table_format_input(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.OpenTableFormatInputProperty"]]:
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.OpenTableFormatInputProperty"]], jsii.get(self, "openTableFormatInput"))
+
+    @open_table_format_input.setter
+    def open_table_format_input(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.OpenTableFormatInputProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__665cbaaa65195b8bbc7411de99becf7db59ef5ca96a0902eefe7c34b8e25afb0)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "openTableFormatInput", value)
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_glue.CfnTable.ColumnProperty",
         jsii_struct_bases=[],
@@ -11241,6 +11465,131 @@ class CfnTable(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_glue.CfnTable.IcebergInputProperty",
+        jsii_struct_bases=[],
+        name_mapping={"metadata_operation": "metadataOperation", "version": "version"},
+    )
+    class IcebergInputProperty:
+        def __init__(
+            self,
+            *,
+            metadata_operation: typing.Optional[builtins.str] = None,
+            version: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''
+            :param metadata_operation: 
+            :param version: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-iceberginput.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_glue as glue
+                
+                iceberg_input_property = glue.CfnTable.IcebergInputProperty(
+                    metadata_operation="metadataOperation",
+                    version="version"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__a5577a3390e460af8ee1e26ea5e72e59fe72e27a2ccecb9955c9c6bdef02fb27)
+                check_type(argname="argument metadata_operation", value=metadata_operation, expected_type=type_hints["metadata_operation"])
+                check_type(argname="argument version", value=version, expected_type=type_hints["version"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if metadata_operation is not None:
+                self._values["metadata_operation"] = metadata_operation
+            if version is not None:
+                self._values["version"] = version
+
+        @builtins.property
+        def metadata_operation(self) -> typing.Optional[builtins.str]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-iceberginput.html#cfn-glue-table-iceberginput-metadataoperation
+            '''
+            result = self._values.get("metadata_operation")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def version(self) -> typing.Optional[builtins.str]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-iceberginput.html#cfn-glue-table-iceberginput-version
+            '''
+            result = self._values.get("version")
+            return typing.cast(typing.Optional[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 "IcebergInputProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_glue.CfnTable.OpenTableFormatInputProperty",
+        jsii_struct_bases=[],
+        name_mapping={"iceberg_input": "icebergInput"},
+    )
+    class OpenTableFormatInputProperty:
+        def __init__(
+            self,
+            *,
+            iceberg_input: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTable.IcebergInputProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''
+            :param iceberg_input: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-opentableformatinput.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_glue as glue
+                
+                open_table_format_input_property = glue.CfnTable.OpenTableFormatInputProperty(
+                    iceberg_input=glue.CfnTable.IcebergInputProperty(
+                        metadata_operation="metadataOperation",
+                        version="version"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__f9f61844cf53db36b4e95a3ba20e8bd9648792e23f16c99fd8c68ece7cae04a4)
+                check_type(argname="argument iceberg_input", value=iceberg_input, expected_type=type_hints["iceberg_input"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if iceberg_input is not None:
+                self._values["iceberg_input"] = iceberg_input
+
+        @builtins.property
+        def iceberg_input(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.IcebergInputProperty"]]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-opentableformatinput.html#cfn-glue-table-opentableformatinput-iceberginput
+            '''
+            result = self._values.get("iceberg_input")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTable.IcebergInputProperty"]], 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 "OpenTableFormatInputProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_glue.CfnTable.OrderProperty",
         jsii_struct_bases=[],
@@ -11990,6 +12339,7 @@ class CfnTable(
             "catalog_id": "catalogId",
             "database_name": "databaseName",
             "name": "name",
+            "region": "region",
         },
     )
     class TableIdentifierProperty:
@@ -11999,12 +12349,14 @@ class CfnTable(
             catalog_id: typing.Optional[builtins.str] = None,
             database_name: typing.Optional[builtins.str] = None,
             name: typing.Optional[builtins.str] = None,
+            region: typing.Optional[builtins.str] = None,
         ) -> None:
             '''A structure that describes a target table for resource linking.
 
             :param catalog_id: The ID of the Data Catalog in which the table resides.
             :param database_name: The name of the catalog database that contains the target table.
             :param name: The name of the target table.
+            :param region: 
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableidentifier.html
             :exampleMetadata: fixture=_generated
@@ -12018,7 +12370,8 @@ class CfnTable(
                 table_identifier_property = glue.CfnTable.TableIdentifierProperty(
                     catalog_id="catalogId",
                     database_name="databaseName",
-                    name="name"
+                    name="name",
+                    region="region"
                 )
             '''
             if __debug__:
@@ -12026,6 +12379,7 @@ class CfnTable(
                 check_type(argname="argument catalog_id", value=catalog_id, expected_type=type_hints["catalog_id"])
                 check_type(argname="argument database_name", value=database_name, expected_type=type_hints["database_name"])
                 check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+                check_type(argname="argument region", value=region, expected_type=type_hints["region"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if catalog_id is not None:
                 self._values["catalog_id"] = catalog_id
@@ -12033,6 +12387,8 @@ class CfnTable(
                 self._values["database_name"] = database_name
             if name is not None:
                 self._values["name"] = name
+            if region is not None:
+                self._values["region"] = region
 
         @builtins.property
         def catalog_id(self) -> typing.Optional[builtins.str]:
@@ -12061,6 +12417,14 @@ class CfnTable(
             result = self._values.get("name")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def region(self) -> typing.Optional[builtins.str]:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableidentifier.html#cfn-glue-table-tableidentifier-region
+            '''
+            result = self._values.get("region")
+            return typing.cast(typing.Optional[builtins.str], result)
+
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -12188,7 +12552,8 @@ class CfnTable(
                     target_table=glue.CfnTable.TableIdentifierProperty(
                         catalog_id="catalogId",
                         database_name="databaseName",
-                        name="name"
+                        name="name",
+                        region="region"
                     ),
                     view_expanded_text="viewExpandedText",
                     view_original_text="viewOriginalText"
@@ -12374,6 +12739,7 @@ class CfnTable(
         "catalog_id": "catalogId",
         "database_name": "databaseName",
         "table_input": "tableInput",
+        "open_table_format_input": "openTableFormatInput",
     },
 )
 class CfnTableProps:
@@ -12383,12 +12749,14 @@ class CfnTableProps:
         catalog_id: builtins.str,
         database_name: builtins.str,
         table_input: typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.TableInputProperty, typing.Dict[builtins.str, typing.Any]]],
+        open_table_format_input: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.OpenTableFormatInputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnTable``.
 
         :param catalog_id: The ID of the Data Catalog in which to create the ``Table`` .
         :param database_name: The name of the database where the table metadata resides. For Hive compatibility, this must be all lowercase.
         :param table_input: A structure used to define a table.
+        :param open_table_format_input: 
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html
         :exampleMetadata: fixture=_generated
@@ -12462,10 +12830,19 @@ class CfnTableProps:
                     target_table=glue.CfnTable.TableIdentifierProperty(
                         catalog_id="catalogId",
                         database_name="databaseName",
-                        name="name"
+                        name="name",
+                        region="region"
                     ),
                     view_expanded_text="viewExpandedText",
                     view_original_text="viewOriginalText"
+                ),
+            
+                # the properties below are optional
+                open_table_format_input=glue.CfnTable.OpenTableFormatInputProperty(
+                    iceberg_input=glue.CfnTable.IcebergInputProperty(
+                        metadata_operation="metadataOperation",
+                        version="version"
+                    )
                 )
             )
         '''
@@ -12474,11 +12851,14 @@ class CfnTableProps:
             check_type(argname="argument catalog_id", value=catalog_id, expected_type=type_hints["catalog_id"])
             check_type(argname="argument database_name", value=database_name, expected_type=type_hints["database_name"])
             check_type(argname="argument table_input", value=table_input, expected_type=type_hints["table_input"])
+            check_type(argname="argument open_table_format_input", value=open_table_format_input, expected_type=type_hints["open_table_format_input"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "catalog_id": catalog_id,
             "database_name": database_name,
             "table_input": table_input,
         }
+        if open_table_format_input is not None:
+            self._values["open_table_format_input"] = open_table_format_input
 
     @builtins.property
     def catalog_id(self) -> builtins.str:
@@ -12514,6 +12894,16 @@ class CfnTableProps:
         assert result is not None, "Required property 'table_input' is missing"
         return typing.cast(typing.Union[_IResolvable_da3f097b, CfnTable.TableInputProperty], result)
 
+    @builtins.property
+    def open_table_format_input(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.OpenTableFormatInputProperty]]:
+        '''
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html#cfn-glue-table-opentableformatinput
+        '''
+        result = self._values.get("open_table_format_input")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.OpenTableFormatInputProperty]], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -13964,7 +14354,9 @@ def _typecheckingstub__204ba6e258d6c443b165b0772162d891e01db52b8bf7b049b0e9d4968
 def _typecheckingstub__dd722ed29ebf9e1505b4d21b5e95cb0f8d4e96b052ed45a497086e92f8d1eb4c(
     *,
     allow_single_column: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    contains_custom_datatype: typing.Optional[typing.Sequence[builtins.str]] = None,
     contains_header: typing.Optional[builtins.str] = None,
+    custom_datatype_configured: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     delimiter: typing.Optional[builtins.str] = None,
     disable_value_trimming: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     header: typing.Optional[typing.Sequence[builtins.str]] = None,
@@ -14213,6 +14605,16 @@ def _typecheckingstub__4c03ffc3d1fa17ed9770b2c448e87c012b6d363001f06ce8b95bdb9c6
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__fc4d48721f48f2b8be2bdcc36b62b7559b104ac87185a032281e5b09d46901e3(
+    *,
+    connection_name: typing.Optional[builtins.str] = None,
+    exclusions: typing.Optional[typing.Sequence[builtins.str]] = None,
+    maximum_traversal_depth: typing.Optional[jsii.Number] = None,
+    paths: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__9cb27c7db73a5c6fa3740f2d4726f453641d40911229d3bb39f26c4402516cf6(
     *,
     connection_name: typing.Optional[builtins.str] = None,
@@ -14269,6 +14671,7 @@ def _typecheckingstub__fe7a457ca9245ce0e51373e4e1d8daf444f9da978c352bc8529931e53
     catalog_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCrawler.CatalogTargetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     delta_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCrawler.DeltaTargetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     dynamo_db_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCrawler.DynamoDBTargetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    iceberg_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCrawler.IcebergTargetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     jdbc_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCrawler.JdbcTargetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     mongo_db_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCrawler.MongoDBTargetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     s3_targets: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCrawler.S3TargetProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -14488,6 +14891,7 @@ def _typecheckingstub__5e1e09205087e89c58802ef33b1c27bb5ad9de3db3e6419d7c72b4906
     *,
     catalog_id: typing.Optional[builtins.str] = None,
     database_name: typing.Optional[builtins.str] = None,
+    region: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -15551,6 +15955,7 @@ def _typecheckingstub__63721068e81107cadbf3e418ec393de98f88a141604f2bb1044b5ae30
     catalog_id: builtins.str,
     database_name: builtins.str,
     table_input: typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.TableInputProperty, typing.Dict[builtins.str, typing.Any]]],
+    open_table_format_input: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.OpenTableFormatInputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -15585,6 +15990,12 @@ def _typecheckingstub__9200a2bfb582a6d400aba47da5ed4d77a8ca52ee0956131ca52cdc582
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__665cbaaa65195b8bbc7411de99becf7db59ef5ca96a0902eefe7c34b8e25afb0(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnTable.OpenTableFormatInputProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__341bb786dd6f598e8fcaf71f90ff3da761cc3d8304f5ad4f6619ba17f44144aa(
     *,
     name: builtins.str,
@@ -15594,6 +16005,21 @@ def _typecheckingstub__341bb786dd6f598e8fcaf71f90ff3da761cc3d8304f5ad4f6619ba17f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a5577a3390e460af8ee1e26ea5e72e59fe72e27a2ccecb9955c9c6bdef02fb27(
+    *,
+    metadata_operation: typing.Optional[builtins.str] = None,
+    version: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__f9f61844cf53db36b4e95a3ba20e8bd9648792e23f16c99fd8c68ece7cae04a4(
+    *,
+    iceberg_input: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.IcebergInputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__0ef4b90841abfe4615325735c716d9eaa2a8839a68d0c4650f1bb4275935dfa1(
     *,
     column: builtins.str,
@@ -15662,6 +16088,7 @@ def _typecheckingstub__cd9fe33086eb487e31769dc922bd060b39cb7e1a4f01a8e8bfa04311b
     catalog_id: typing.Optional[builtins.str] = None,
     database_name: typing.Optional[builtins.str] = None,
     name: typing.Optional[builtins.str] = None,
+    region: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -15688,6 +16115,7 @@ def _typecheckingstub__1fa7a95b739eec87307cf104cf3e05eef39d32fd60cc53851b43bd980
     catalog_id: builtins.str,
     database_name: builtins.str,
     table_input: typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.TableInputProperty, typing.Dict[builtins.str, typing.Any]]],
+    open_table_format_input: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTable.OpenTableFormatInputProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass