pulumi-gcp 7.27.0a1718279079__py3-none-any.whl → 7.28.0__py3-none-any.whl

pulumi_gcp/compute/target_https_proxy.py

@@ -34,11 +34,13 @@ class TargetHttpsProxyArgs:
                
                - - -
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_manager_certificates: URLs to certificate manager certificate resources that are used to authenticate connections between users and the load balancer.
-               Currently, you may specify up to 15 certificates. Certificate manager certificates do not apply when the load balancing scheme is set to INTERNAL_SELF_MANAGED.
+               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
+               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
                sslCertificates and certificateManagerCertificates fields can not be defined together.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificates/{resourceName}` or just the self_link `projects/{project}/locations/{location}/certificates/{resourceName}`
         :param pulumi.Input[str] certificate_map: A reference to the CertificateMap resource uri that identifies a certificate map
-               associated with the given target proxy. This field can only be set for global target proxies.
+               associated with the given target proxy. This field is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
+               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[int] http_keep_alive_timeout_sec: Specifies how long to keep a connection open, after completing a response,
@@ -125,7 +127,8 @@ class TargetHttpsProxyArgs:
     def certificate_manager_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
         URLs to certificate manager certificate resources that are used to authenticate connections between users and the load balancer.
-        Currently, you may specify up to 15 certificates. Certificate manager certificates do not apply when the load balancing scheme is set to INTERNAL_SELF_MANAGED.
+        Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
+        For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
         sslCertificates and certificateManagerCertificates fields can not be defined together.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificates/{resourceName}` or just the self_link `projects/{project}/locations/{location}/certificates/{resourceName}`
         """
@@ -140,7 +143,8 @@ class TargetHttpsProxyArgs:
     def certificate_map(self) -> Optional[pulumi.Input[str]]:
         """
         A reference to the CertificateMap resource uri that identifies a certificate map
-        associated with the given target proxy. This field can only be set for global target proxies.
+        associated with the given target proxy. This field is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
+        For INTERNAL_MANAGED, use certificate_manager_certificates instead.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         """
         return pulumi.get(self, "certificate_map")
@@ -309,11 +313,13 @@ class _TargetHttpsProxyState:
         """
         Input properties used for looking up and filtering TargetHttpsProxy resources.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_manager_certificates: URLs to certificate manager certificate resources that are used to authenticate connections between users and the load balancer.
-               Currently, you may specify up to 15 certificates. Certificate manager certificates do not apply when the load balancing scheme is set to INTERNAL_SELF_MANAGED.
+               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
+               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
                sslCertificates and certificateManagerCertificates fields can not be defined together.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificates/{resourceName}` or just the self_link `projects/{project}/locations/{location}/certificates/{resourceName}`
         :param pulumi.Input[str] certificate_map: A reference to the CertificateMap resource uri that identifies a certificate map
-               associated with the given target proxy. This field can only be set for global target proxies.
+               associated with the given target proxy. This field is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
+               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
         :param pulumi.Input[str] description: An optional description of this resource.
@@ -399,7 +405,8 @@ class _TargetHttpsProxyState:
     def certificate_manager_certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
         URLs to certificate manager certificate resources that are used to authenticate connections between users and the load balancer.
-        Currently, you may specify up to 15 certificates. Certificate manager certificates do not apply when the load balancing scheme is set to INTERNAL_SELF_MANAGED.
+        Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
+        For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
         sslCertificates and certificateManagerCertificates fields can not be defined together.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificates/{resourceName}` or just the self_link `projects/{project}/locations/{location}/certificates/{resourceName}`
         """
@@ -414,7 +421,8 @@ class _TargetHttpsProxyState:
     def certificate_map(self) -> Optional[pulumi.Input[str]]:
         """
         A reference to the CertificateMap resource uri that identifies a certificate map
-        associated with the given target proxy. This field can only be set for global target proxies.
+        associated with the given target proxy. This field is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
+        For INTERNAL_MANAGED, use certificate_manager_certificates instead.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         """
         return pulumi.get(self, "certificate_map")
@@ -870,11 +878,13 @@ class TargetHttpsProxy(pulumi.CustomResource):
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_manager_certificates: URLs to certificate manager certificate resources that are used to authenticate connections between users and the load balancer.
-               Currently, you may specify up to 15 certificates. Certificate manager certificates do not apply when the load balancing scheme is set to INTERNAL_SELF_MANAGED.
+               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
+               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
                sslCertificates and certificateManagerCertificates fields can not be defined together.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificates/{resourceName}` or just the self_link `projects/{project}/locations/{location}/certificates/{resourceName}`
         :param pulumi.Input[str] certificate_map: A reference to the CertificateMap resource uri that identifies a certificate map
-               associated with the given target proxy. This field can only be set for global target proxies.
+               associated with the given target proxy. This field is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
+               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[int] http_keep_alive_timeout_sec: Specifies how long to keep a connection open, after completing a response,
@@ -1248,11 +1258,13 @@ class TargetHttpsProxy(pulumi.CustomResource):
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_manager_certificates: URLs to certificate manager certificate resources that are used to authenticate connections between users and the load balancer.
-               Currently, you may specify up to 15 certificates. Certificate manager certificates do not apply when the load balancing scheme is set to INTERNAL_SELF_MANAGED.
+               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
+               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
                sslCertificates and certificateManagerCertificates fields can not be defined together.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificates/{resourceName}` or just the self_link `projects/{project}/locations/{location}/certificates/{resourceName}`
         :param pulumi.Input[str] certificate_map: A reference to the CertificateMap resource uri that identifies a certificate map
-               associated with the given target proxy. This field can only be set for global target proxies.
+               associated with the given target proxy. This field is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
+               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
                Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
         :param pulumi.Input[str] description: An optional description of this resource.
@@ -1328,7 +1340,8 @@ class TargetHttpsProxy(pulumi.CustomResource):
     def certificate_manager_certificates(self) -> pulumi.Output[Optional[Sequence[str]]]:
         """
         URLs to certificate manager certificate resources that are used to authenticate connections between users and the load balancer.
-        Currently, you may specify up to 15 certificates. Certificate manager certificates do not apply when the load balancing scheme is set to INTERNAL_SELF_MANAGED.
+        Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
+        For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
         sslCertificates and certificateManagerCertificates fields can not be defined together.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificates/{resourceName}` or just the self_link `projects/{project}/locations/{location}/certificates/{resourceName}`
         """
@@ -1339,7 +1352,8 @@ class TargetHttpsProxy(pulumi.CustomResource):
     def certificate_map(self) -> pulumi.Output[Optional[str]]:
         """
         A reference to the CertificateMap resource uri that identifies a certificate map
-        associated with the given target proxy. This field can only be set for global target proxies.
+        associated with the given target proxy. This field is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
+        For INTERNAL_MANAGED, use certificate_manager_certificates instead.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         """
         return pulumi.get(self, "certificate_map")

pulumi_gcp/config/__init__.pyi

@@ -230,6 +230,8 @@ loggingCustomEndpoint: Optional[str]
 
 lookerCustomEndpoint: Optional[str]
 
+managedKafkaCustomEndpoint: Optional[str]
+
 memcacheCustomEndpoint: Optional[str]
 
 migrationCenterCustomEndpoint: Optional[str]

pulumi_gcp/config/vars.py

@@ -456,6 +456,10 @@ class _ExportableConfig(types.ModuleType):
     def looker_custom_endpoint(self) -> Optional[str]:
         return __config__.get('lookerCustomEndpoint')
 
+    @property
+    def managed_kafka_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('managedKafkaCustomEndpoint')
+
     @property
     def memcache_custom_endpoint(self) -> Optional[str]:
         return __config__.get('memcacheCustomEndpoint')

pulumi_gcp/container/_inputs.py

@@ -11092,7 +11092,7 @@ class ClusterSecurityPostureConfigArgs:
                  mode: Optional[pulumi.Input[str]] = None,
                  vulnerability_mode: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED` and `BASIC`.
+        :param pulumi.Input[str] mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED`, `BASIC`, and `ENTERPRISE`.
         :param pulumi.Input[str] vulnerability_mode: Sets the mode of the Kubernetes security posture API's workload vulnerability scanning. Available options include `VULNERABILITY_DISABLED`, `VULNERABILITY_BASIC` and `VULNERABILITY_ENTERPRISE`.
         """
         if mode is not None:
@@ -11104,7 +11104,7 @@ class ClusterSecurityPostureConfigArgs:
     @pulumi.getter
     def mode(self) -> Optional[pulumi.Input[str]]:
         """
-        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED` and `BASIC`.
+        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED`, `BASIC`, and `ENTERPRISE`.
         """
         return pulumi.get(self, "mode")
 

pulumi_gcp/container/outputs.py

@@ -12062,7 +12062,7 @@ class ClusterSecurityPostureConfig(dict):
                  mode: Optional[str] = None,
                  vulnerability_mode: Optional[str] = None):
         """
-        :param str mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED` and `BASIC`.
+        :param str mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED`, `BASIC`, and `ENTERPRISE`.
         :param str vulnerability_mode: Sets the mode of the Kubernetes security posture API's workload vulnerability scanning. Available options include `VULNERABILITY_DISABLED`, `VULNERABILITY_BASIC` and `VULNERABILITY_ENTERPRISE`.
         """
         if mode is not None:
@@ -12074,7 +12074,7 @@ class ClusterSecurityPostureConfig(dict):
     @pulumi.getter
     def mode(self) -> Optional[str]:
         """
-        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED` and `BASIC`.
+        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED`, `BASIC`, and `ENTERPRISE`.
         """
         return pulumi.get(self, "mode")
 
@@ -19847,7 +19847,7 @@ class GetClusterSecurityPostureConfigResult(dict):
                  mode: str,
                  vulnerability_mode: str):
         """
-        :param str mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include DISABLED and BASIC.
+        :param str mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include DISABLED, BASIC, and ENTERPRISE.
         :param str vulnerability_mode: Sets the mode of the Kubernetes security posture API's workload vulnerability scanning. Available options include VULNERABILITY_DISABLED, VULNERABILITY_BASIC and VULNERABILITY_ENTERPRISE.
         """
         pulumi.set(__self__, "mode", mode)
@@ -19857,7 +19857,7 @@ class GetClusterSecurityPostureConfigResult(dict):
     @pulumi.getter
     def mode(self) -> str:
         """
-        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include DISABLED and BASIC.
+        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include DISABLED, BASIC, and ENTERPRISE.
         """
         return pulumi.get(self, "mode")
 

pulumi_gcp/discoveryengine/_inputs.py

@@ -14,6 +14,13 @@ __all__ = [
     'ChatEngineChatEngineConfigAgentCreationConfigArgs',
     'ChatEngineChatEngineMetadataArgs',
     'ChatEngineCommonConfigArgs',
+    'DataStoreDocumentProcessingConfigArgs',
+    'DataStoreDocumentProcessingConfigDefaultParsingConfigArgs',
+    'DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs',
+    'DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs',
+    'DataStoreDocumentProcessingConfigParsingConfigOverrideArgs',
+    'DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs',
+    'DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs',
     'SearchEngineCommonConfigArgs',
     'SearchEngineSearchEngineConfigArgs',
 ]
@@ -163,6 +170,226 @@ class ChatEngineCommonConfigArgs:
         pulumi.set(self, "company_name", value)
 
 
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigArgs:
+    def __init__(__self__, *,
+                 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['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.
+               Structure is documented below.
+        :param pulumi.Input[str] name: (Output)
+               The full resource name of the Document Processing Config. Format:
+               `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 default_parsing_config is not None:
+            pulumi.set(__self__, "default_parsing_config", default_parsing_config)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if parsing_config_overrides is not None:
+            pulumi.set(__self__, "parsing_config_overrides", parsing_config_overrides)
+
+    @property
+    @pulumi.getter(name="defaultParsingConfig")
+    def default_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigArgs']]:
+        """
+        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.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "default_parsing_config")
+
+    @default_parsing_config.setter
+    def default_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigArgs']]):
+        pulumi.set(self, "default_parsing_config", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The full resource name of the Document Processing Config. Format:
+        `projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}/documentProcessingConfig`.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="parsingConfigOverrides")
+    def parsing_config_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideArgs']]]]:
+        """
+        Map from file type to override the default parsing configuration based on the file type. Supported keys:
+        """
+        return pulumi.get(self, "parsing_config_overrides")
+
+    @parsing_config_overrides.setter
+    def parsing_config_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideArgs']]]]):
+        pulumi.set(self, "parsing_config_overrides", value)
+
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigDefaultParsingConfigArgs:
+    def __init__(__self__, *,
+                 digital_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs']] = None,
+                 ocr_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs']] = None):
+        """
+        :param pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs'] digital_parsing_config: Configurations applied to digital 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 ocr_parsing_config is not None:
+            pulumi.set(__self__, "ocr_parsing_config", ocr_parsing_config)
+
+    @property
+    @pulumi.getter(name="digitalParsingConfig")
+    def digital_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs']]:
+        """
+        Configurations applied to digital parser.
+        """
+        return pulumi.get(self, "digital_parsing_config")
+
+    @digital_parsing_config.setter
+    def digital_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs']]):
+        pulumi.set(self, "digital_parsing_config", value)
+
+    @property
+    @pulumi.getter(name="ocrParsingConfig")
+    def ocr_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs']]:
+        """
+        Configurations applied to OCR parser. Currently it only applies to PDFs.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ocr_parsing_config")
+
+    @ocr_parsing_config.setter
+    def ocr_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs']]):
+        pulumi.set(self, "ocr_parsing_config", value)
+
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs:
+    def __init__(__self__):
+        pass
+
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs:
+    def __init__(__self__, *,
+                 use_native_text: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] use_native_text: If true, will use native text instead of OCR text on pages containing native text.
+        """
+        if use_native_text is not None:
+            pulumi.set(__self__, "use_native_text", use_native_text)
+
+    @property
+    @pulumi.getter(name="useNativeText")
+    def use_native_text(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, will use native text instead of OCR text on pages containing native text.
+        """
+        return pulumi.get(self, "use_native_text")
+
+    @use_native_text.setter
+    def use_native_text(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "use_native_text", value)
+
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigParsingConfigOverrideArgs:
+    def __init__(__self__, *,
+                 file_type: pulumi.Input[str],
+                 digital_parsing_config: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs']] = 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['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 ocr_parsing_config is not None:
+            pulumi.set(__self__, "ocr_parsing_config", ocr_parsing_config)
+
+    @property
+    @pulumi.getter(name="fileType")
+    def file_type(self) -> pulumi.Input[str]:
+        """
+        The identifier for this object. Format specified above.
+        """
+        return pulumi.get(self, "file_type")
+
+    @file_type.setter
+    def file_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "file_type", value)
+
+    @property
+    @pulumi.getter(name="digitalParsingConfig")
+    def digital_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs']]:
+        """
+        Configurations applied to digital parser.
+        """
+        return pulumi.get(self, "digital_parsing_config")
+
+    @digital_parsing_config.setter
+    def digital_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs']]):
+        pulumi.set(self, "digital_parsing_config", value)
+
+    @property
+    @pulumi.getter(name="ocrParsingConfig")
+    def ocr_parsing_config(self) -> Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs']]:
+        """
+        Configurations applied to OCR parser. Currently it only applies to PDFs.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "ocr_parsing_config")
+
+    @ocr_parsing_config.setter
+    def ocr_parsing_config(self, value: Optional[pulumi.Input['DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs']]):
+        pulumi.set(self, "ocr_parsing_config", value)
+
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs:
+    def __init__(__self__):
+        pass
+
+
+@pulumi.input_type
+class DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs:
+    def __init__(__self__, *,
+                 use_native_text: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] use_native_text: If true, will use native text instead of OCR text on pages containing native text.
+        """
+        if use_native_text is not None:
+            pulumi.set(__self__, "use_native_text", use_native_text)
+
+    @property
+    @pulumi.getter(name="useNativeText")
+    def use_native_text(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If true, will use native text instead of OCR text on pages containing native text.
+        """
+        return pulumi.get(self, "use_native_text")
+
+    @use_native_text.setter
+    def use_native_text(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "use_native_text", value)
+
+
 @pulumi.input_type
 class SearchEngineCommonConfigArgs:
     def __init__(__self__, *,