pulumi-gcp 8.1.0__py3-none-any.whl → 8.1.0a1726293903__py3-none-any.whl

pulumi_gcp/datastream/stream.py

@@ -47,8 +47,7 @@ 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. Possible
-               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
+        :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[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.
         """
@@ -187,8 +186,7 @@ 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. Possible
-        values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
         """
         return pulumi.get(self, "desired_state")
 
@@ -245,8 +243,7 @@ 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. Possible
-               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
+        :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['StreamDestinationConfigArgs'] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -348,8 +345,7 @@ 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. Possible
-        values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
         """
         return pulumi.get(self, "desired_state")
 
@@ -928,96 +924,6 @@ 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={
@@ -1328,8 +1234,7 @@ 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. Possible
-               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
+        :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[Union['StreamDestinationConfigArgs', 'StreamDestinationConfigArgsDict']] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -1765,96 +1670,6 @@ 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={
@@ -2260,8 +2075,7 @@ 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. Possible
-               values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
+        :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[Union['StreamDestinationConfigArgs', 'StreamDestinationConfigArgsDict']] destination_config: Destination connection profile configuration.
                Structure is documented below.
         :param pulumi.Input[str] display_name: Display name.
@@ -2336,8 +2150,7 @@ 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. Possible
-        values: NOT_STARTED, RUNNING, PAUSED. Default: NOT_STARTED
+        Desired state of the Stream. Set this field to 'RUNNING' to start the stream, and 'PAUSED' to pause the stream.
         """
         return pulumi.get(self, "desired_state")
 

pulumi_gcp/discoveryengine/_inputs.py

@@ -25,24 +25,16 @@ __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',
@@ -252,11 +244,6 @@ 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
@@ -280,13 +267,10 @@ 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.
@@ -296,8 +280,6 @@ 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:
@@ -305,19 +287,6 @@ 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']]:
@@ -360,109 +329,12 @@ 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.
@@ -475,18 +347,14 @@ 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)
 
@@ -502,18 +370,6 @@ 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']]:
@@ -540,18 +396,6 @@ 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]]
@@ -594,10 +438,6 @@ 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.
@@ -611,20 +451,16 @@ 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)
 
@@ -652,18 +488,6 @@ 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']]:
@@ -690,18 +514,6 @@ 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]]