pulumi-gcp 8.0.0a1726253601__py3-none-any.whl → 8.1.0__py3-none-any.whl

pulumi_gcp/datastream/stream.py

@@ -47,7 +47,8 @@ class StreamArgs:
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream. Possible
+               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Labels. **Note**: This field is non-authoritative, and will only manage the labels present in your configuration. Please
                refer to the field 'effective_labels' for all of the labels present on the resource.
         """
@@ -186,7 +187,8 @@ class StreamArgs:
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream. Possible
+        values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
         """
         return pulumi.get(self, "desired_state")
 
@@ -243,7 +245,8 @@ class _StreamState:
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream. Possible
+               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
         :param pulumi.Input['StreamDestinationConfigArgs'] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -345,7 +348,8 @@ class _StreamState:
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream. Possible
+        values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
         """
         return pulumi.get(self, "desired_state")
 
@@ -924,6 +928,96 @@ class Stream(pulumi.CustomResource):
                             }],
                         }],
                     },
+                    "transaction_logs": {},
+                },
+            },
+            destination_config={
+                "destination_connection_profile": destination.id,
+                "bigquery_destination_config": {
+                    "data_freshness": "900s",
+                    "source_hierarchy_datasets": {
+                        "dataset_template": {
+                            "location": "us-central1",
+                        },
+                    },
+                },
+            },
+            backfill_none={})
+        ```
+        ### Datastream Stream Sql Server Change Tables
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        instance = gcp.sql.DatabaseInstance("instance",
+            name="sql-server",
+            database_version="SQLSERVER_2019_STANDARD",
+            region="us-central1",
+            root_password="root-password",
+            deletion_protection=True,
+            settings={
+                "tier": "db-custom-2-4096",
+                "ip_configuration": {
+                    "authorized_networks": [
+                        {
+                            "value": "34.71.242.81",
+                        },
+                        {
+                            "value": "34.72.28.29",
+                        },
+                        {
+                            "value": "34.67.6.157",
+                        },
+                        {
+                            "value": "34.67.234.134",
+                        },
+                        {
+                            "value": "34.72.239.218",
+                        },
+                    ],
+                },
+            })
+        user = gcp.sql.User("user",
+            name="user",
+            instance=instance.name,
+            password="password")
+        db = gcp.sql.Database("db",
+            name="db",
+            instance=instance.name,
+            opts = pulumi.ResourceOptions(depends_on=[user]))
+        source = gcp.datastream.ConnectionProfile("source",
+            display_name="SQL Server Source",
+            location="us-central1",
+            connection_profile_id="source-profile",
+            sql_server_profile={
+                "hostname": instance.public_ip_address,
+                "port": 1433,
+                "username": user.name,
+                "password": user.password,
+                "database": db.name,
+            })
+        destination = gcp.datastream.ConnectionProfile("destination",
+            display_name="BigQuery Destination",
+            location="us-central1",
+            connection_profile_id="destination-profile",
+            bigquery_profile={})
+        default = gcp.datastream.Stream("default",
+            display_name="SQL Server to BigQuery",
+            location="us-central1",
+            stream_id="stream",
+            source_config={
+                "source_connection_profile": source.id,
+                "sql_server_source_config": {
+                    "include_objects": {
+                        "schemas": [{
+                            "schema": "schema",
+                            "tables": [{
+                                "table": "table",
+                            }],
+                        }],
+                    },
+                    "change_tables": {},
                 },
             },
             destination_config={
@@ -1234,7 +1328,8 @@ class Stream(pulumi.CustomResource):
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream. Possible
+               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
         :param pulumi.Input[Union['StreamDestinationConfigArgs', 'StreamDestinationConfigArgsDict']] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -1670,6 +1765,96 @@ class Stream(pulumi.CustomResource):
                             }],
                         }],
                     },
+                    "transaction_logs": {},
+                },
+            },
+            destination_config={
+                "destination_connection_profile": destination.id,
+                "bigquery_destination_config": {
+                    "data_freshness": "900s",
+                    "source_hierarchy_datasets": {
+                        "dataset_template": {
+                            "location": "us-central1",
+                        },
+                    },
+                },
+            },
+            backfill_none={})
+        ```
+        ### Datastream Stream Sql Server Change Tables
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        instance = gcp.sql.DatabaseInstance("instance",
+            name="sql-server",
+            database_version="SQLSERVER_2019_STANDARD",
+            region="us-central1",
+            root_password="root-password",
+            deletion_protection=True,
+            settings={
+                "tier": "db-custom-2-4096",
+                "ip_configuration": {
+                    "authorized_networks": [
+                        {
+                            "value": "34.71.242.81",
+                        },
+                        {
+                            "value": "34.72.28.29",
+                        },
+                        {
+                            "value": "34.67.6.157",
+                        },
+                        {
+                            "value": "34.67.234.134",
+                        },
+                        {
+                            "value": "34.72.239.218",
+                        },
+                    ],
+                },
+            })
+        user = gcp.sql.User("user",
+            name="user",
+            instance=instance.name,
+            password="password")
+        db = gcp.sql.Database("db",
+            name="db",
+            instance=instance.name,
+            opts = pulumi.ResourceOptions(depends_on=[user]))
+        source = gcp.datastream.ConnectionProfile("source",
+            display_name="SQL Server Source",
+            location="us-central1",
+            connection_profile_id="source-profile",
+            sql_server_profile={
+                "hostname": instance.public_ip_address,
+                "port": 1433,
+                "username": user.name,
+                "password": user.password,
+                "database": db.name,
+            })
+        destination = gcp.datastream.ConnectionProfile("destination",
+            display_name="BigQuery Destination",
+            location="us-central1",
+            connection_profile_id="destination-profile",
+            bigquery_profile={})
+        default = gcp.datastream.Stream("default",
+            display_name="SQL Server to BigQuery",
+            location="us-central1",
+            stream_id="stream",
+            source_config={
+                "source_connection_profile": source.id,
+                "sql_server_source_config": {
+                    "include_objects": {
+                        "schemas": [{
+                            "schema": "schema",
+                            "tables": [{
+                                "table": "table",
+                            }],
+                        }],
+                    },
+                    "change_tables": {},
                 },
             },
             destination_config={
@@ -2075,7 +2260,8 @@ class Stream(pulumi.CustomResource):
         :param pulumi.Input[bool] create_without_validation: Create the stream without validating it.
         :param pulumi.Input[str] customer_managed_encryption_key: A reference to a KMS encryption key. If provided, it will be used to encrypt the data. If left blank, data will be
                encrypted using an internal Stream-specific encryption key provisioned through KMS.
-        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        :param pulumi.Input[str] desired_state: Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream. Possible
+               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
         :param pulumi.Input[Union['StreamDestinationConfigArgs', 'StreamDestinationConfigArgsDict']] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -2150,7 +2336,8 @@ class Stream(pulumi.CustomResource):
     @pulumi.getter(name="desiredState")
     def desired_state(self) -> pulumi.Output[Optional[str]]:
         """
-        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream. Possible
+        values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
         """
         return pulumi.get(self, "desired_state")
 

pulumi_gcp/discoveryengine/_inputs.py

@@ -25,16 +25,24 @@ __all__ = [
     'ChatEngineCommonConfigArgsDict',
     'DataStoreDocumentProcessingConfigArgs',
     'DataStoreDocumentProcessingConfigArgsDict',
+    'DataStoreDocumentProcessingConfigChunkingConfigArgs',
+    'DataStoreDocumentProcessingConfigChunkingConfigArgsDict',
+    'DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgs',
+    'DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgsDict',
     'DataStoreDocumentProcessingConfigDefaultParsingConfigArgs',
     'DataStoreDocumentProcessingConfigDefaultParsingConfigArgsDict',
     'DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs',
     'DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgsDict',
+    'DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgs',
+    'DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgsDict',
     'DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs',
     'DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgsDict',
     'DataStoreDocumentProcessingConfigParsingConfigOverrideArgs',
     'DataStoreDocumentProcessingConfigParsingConfigOverrideArgsDict',
     'DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs',
     'DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgsDict',
+    'DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgs',
+    'DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgsDict',
     'DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs',
     'DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgsDict',
     'SearchEngineCommonConfigArgs',
@@ -244,6 +252,11 @@ class ChatEngineCommonConfigArgs:
 
 if not MYPY:
     class DataStoreDocumentProcessingConfigArgsDict(TypedDict):
+        chunking_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigArgsDict']]
+        """
+        Whether chunking mode is enabled.
+        Structure is documented below.
+        """
         default_parsing_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigArgsDict']]
         """
         Configurations for default Document parser. If not specified, this resource
@@ -267,10 +280,13 @@ elif False:
 @pulumi.input_type
 class DataStoreDocumentProcessingConfigArgs:
     def __init__(__self__, *,
+                 chunking_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigArgs']] = None,
                  default_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigArgs']] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  parsing_config_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideArgs']]]] = None):
         """
+        :param pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigArgs'] chunking_config: Whether chunking mode is enabled.
+               Structure is documented below.
         :param pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigArgs'] default_parsing_config: Configurations for default Document parser. If not specified, this resource
                will be configured to use a default DigitalParsingConfig, and the default parsing
                config will be applied to all file types for Document parsing.
@@ -280,6 +296,8 @@ class DataStoreDocumentProcessingConfigArgs:
                `projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}/documentProcessingConfig`.
         :param pulumi.Input[Sequence[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideArgs']]] parsing_config_overrides: Map from file type to override the default parsing configuration based on the file type. Supported keys:
         """
+        if chunking_config is not None:
+            pulumi.set(__self__, "chunking_config", chunking_config)
         if default_parsing_config is not None:
             pulumi.set(__self__, "default_parsing_config", default_parsing_config)
         if name is not None:
@@ -287,6 +305,19 @@ class DataStoreDocumentProcessingConfigArgs:
         if parsing_config_overrides is not None:
             pulumi.set(__self__, "parsing_config_overrides", parsing_config_overrides)
 
+    @property
+    @pulumi.getter(name="chunkingConfig")
+    def chunking_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigArgs']]:
+        """
+        Whether chunking mode is enabled.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "chunking_config")
+
+    @chunking_config.setter
+    def chunking_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigArgs']]):
+        pulumi.set(self, "chunking_config", value)
+
     @property
     @pulumi.getter(name="defaultParsingConfig")
     def default_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigArgs']]:
@@ -329,12 +360,109 @@ class DataStoreDocumentProcessingConfigArgs:
         pulumi.set(self, "parsing_config_overrides", value)
 
 
+if not MYPY:
+    class DataStoreDocumentProcessingConfigChunkingConfigArgsDict(TypedDict):
+        layout_based_chunking_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgsDict']]
+        """
+        Configuration for the layout based chunking.
+        Structure is documented below.
+        """
+elif False:
+    DataStoreDocumentProcessingConfigChunkingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigChunkingConfigArgs:
+    def __init__(__self__, *,
+                 layout_based_chunking_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgs']] = None):
+        """
+        :param pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgs'] layout_based_chunking_config: Configuration for the layout based chunking.
+               Structure is documented below.
+        """
+        if layout_based_chunking_config is not None:
+            pulumi.set(__self__, "layout_based_chunking_config", layout_based_chunking_config)
+
+    @property
+    @pulumi.getter(name="layoutBasedChunkingConfig")
+    def layout_based_chunking_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgs']]:
+        """
+        Configuration for the layout based chunking.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "layout_based_chunking_config")
+
+    @layout_based_chunking_config.setter
+    def layout_based_chunking_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgs']]):
+        pulumi.set(self, "layout_based_chunking_config", value)
+
+
+if not MYPY:
+    class DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgsDict(TypedDict):
+        chunk_size: NotRequired[pulumi.Input[int]]
+        """
+        The token size limit for each chunk.
+        Supported values: 100-500 (inclusive). Default value: 500.
+        """
+        include_ancestor_headings: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to include appending different levels of headings to chunks from the middle of the document to prevent context loss.
+        Default value: False.
+        """
+elif False:
+    DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigChunkingConfigLayoutBasedChunkingConfigArgs:
+    def __init__(__self__, *,
+                 chunk_size: Optional[pulumi.Input[int]] = None,
+                 include_ancestor_headings: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[int] chunk_size: The token size limit for each chunk.
+               Supported values: 100-500 (inclusive). Default value: 500.
+        :param pulumi.Input[bool] include_ancestor_headings: Whether to include appending different levels of headings to chunks from the middle of the document to prevent context loss.
+               Default value: False.
+        """
+        if chunk_size is not None:
+            pulumi.set(__self__, "chunk_size", chunk_size)
+        if include_ancestor_headings is not None:
+            pulumi.set(__self__, "include_ancestor_headings", include_ancestor_headings)
+
+    @property
+    @pulumi.getter(name="chunkSize")
+    def chunk_size(self) -> Optional[pulumi.Input[int]]:
+        """
+        The token size limit for each chunk.
+        Supported values: 100-500 (inclusive). Default value: 500.
+        """
+        return pulumi.get(self, "chunk_size")
+
+    @chunk_size.setter
+    def chunk_size(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "chunk_size", value)
+
+    @property
+    @pulumi.getter(name="includeAncestorHeadings")
+    def include_ancestor_headings(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to include appending different levels of headings to chunks from the middle of the document to prevent context loss.
+        Default value: False.
+        """
+        return pulumi.get(self, "include_ancestor_headings")
+
+    @include_ancestor_headings.setter
+    def include_ancestor_headings(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "include_ancestor_headings", value)
+
+
 if not MYPY:
     class DataStoreDocumentProcessingConfigDefaultParsingConfigArgsDict(TypedDict):
         digital_parsing_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgsDict']]
         """
         Configurations applied to digital parser.
         """
+        layout_parsing_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgsDict']]
+        """
+        Configurations applied to layout parser.
+        """
         ocr_parsing_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgsDict']]
         """
         Configurations applied to OCR parser. Currently it only applies to PDFs.
@@ -347,14 +475,18 @@ elif False:
 class DataStoreDocumentProcessingConfigDefaultParsingConfigArgs:
     def __init__(__self__, *,
                  digital_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs']] = None,
+                 layout_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgs']] = None,
                  ocr_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs']] = None):
         """
         :param pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs'] digital_parsing_config: Configurations applied to digital parser.
+        :param pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgs'] layout_parsing_config: Configurations applied to layout parser.
         :param pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs'] ocr_parsing_config: Configurations applied to OCR parser. Currently it only applies to PDFs.
                Structure is documented below.
         """
         if digital_parsing_config is not None:
             pulumi.set(__self__, "digital_parsing_config", digital_parsing_config)
+        if layout_parsing_config is not None:
+            pulumi.set(__self__, "layout_parsing_config", layout_parsing_config)
         if ocr_parsing_config is not None:
             pulumi.set(__self__, "ocr_parsing_config", ocr_parsing_config)
 
@@ -370,6 +502,18 @@ class DataStoreDocumentProcessingConfigDefaultParsingConfigArgs:
     def digital_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs']]):
         pulumi.set(self, "digital_parsing_config", value)
 
+    @property
+    @pulumi.getter(name="layoutParsingConfig")
+    def layout_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgs']]:
+        """
+        Configurations applied to layout parser.
+        """
+        return pulumi.get(self, "layout_parsing_config")
+
+    @layout_parsing_config.setter
+    def layout_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgs']]):
+        pulumi.set(self, "layout_parsing_config", value)
+
     @property
     @pulumi.getter(name="ocrParsingConfig")
     def ocr_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs']]:
@@ -396,6 +540,18 @@ class DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigA
         pass
 
 
+if not MYPY:
+    class DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgsDict(TypedDict):
+        pass
+elif False:
+    DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigDefaultParsingConfigLayoutParsingConfigArgs:
+    def __init__(__self__):
+        pass
+
+
 if not MYPY:
     class DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgsDict(TypedDict):
         use_native_text: NotRequired[pulumi.Input[bool]]
@@ -438,6 +594,10 @@ if not MYPY:
         """
         Configurations applied to digital parser.
         """
+        layout_parsing_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgsDict']]
+        """
+        Configurations applied to layout parser.
+        """
         ocr_parsing_config: NotRequired[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgsDict']]
         """
         Configurations applied to OCR parser. Currently it only applies to PDFs.
@@ -451,16 +611,20 @@ class DataStoreDocumentProcessingConfigParsingConfigOverrideArgs:
     def __init__(__self__, *,
                  file_type: pulumi.Input[str],
                  digital_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs']] = None,
+                 layout_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgs']] = None,
                  ocr_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs']] = None):
         """
         :param pulumi.Input[str] file_type: The identifier for this object. Format specified above.
         :param pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs'] digital_parsing_config: Configurations applied to digital parser.
+        :param pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgs'] layout_parsing_config: Configurations applied to layout parser.
         :param pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs'] ocr_parsing_config: Configurations applied to OCR parser. Currently it only applies to PDFs.
                Structure is documented below.
         """
         pulumi.set(__self__, "file_type", file_type)
         if digital_parsing_config is not None:
             pulumi.set(__self__, "digital_parsing_config", digital_parsing_config)
+        if layout_parsing_config is not None:
+            pulumi.set(__self__, "layout_parsing_config", layout_parsing_config)
         if ocr_parsing_config is not None:
             pulumi.set(__self__, "ocr_parsing_config", ocr_parsing_config)
 
@@ -488,6 +652,18 @@ class DataStoreDocumentProcessingConfigParsingConfigOverrideArgs:
     def digital_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs']]):
         pulumi.set(self, "digital_parsing_config", value)
 
+    @property
+    @pulumi.getter(name="layoutParsingConfig")
+    def layout_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgs']]:
+        """
+        Configurations applied to layout parser.
+        """
+        return pulumi.get(self, "layout_parsing_config")
+
+    @layout_parsing_config.setter
+    def layout_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgs']]):
+        pulumi.set(self, "layout_parsing_config", value)
+
     @property
     @pulumi.getter(name="ocrParsingConfig")
     def ocr_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs']]:
@@ -514,6 +690,18 @@ class DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfig
         pass
 
 
+if not MYPY:
+    class DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgsDict(TypedDict):
+        pass
+elif False:
+    DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigParsingConfigOverrideLayoutParsingConfigArgs:
+    def __init__(__self__):
+        pass
+
+
 if not MYPY:
     class DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgsDict(TypedDict):
         use_native_text: NotRequired[pulumi.Input[bool]]