pulumi-gcp 7.28.0__py3-none-any.whl → 7.28.0a1718754929__py3-none-any.whl

pulumi_gcp/compute/target_https_proxy.py

@@ -34,13 +34,11 @@ 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.
-               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
-               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
+               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.
                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 is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
-               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
+               associated with the given target proxy. This field can only be set for global target proxies.
                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,
@@ -127,8 +125,7 @@ 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.
-        Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
-        For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
+        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.
         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}`
         """
@@ -143,8 +140,7 @@ 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 is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
-        For INTERNAL_MANAGED, use certificate_manager_certificates instead.
+        associated with the given target proxy. This field can only be set for global target proxies.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         """
         return pulumi.get(self, "certificate_map")
@@ -313,13 +309,11 @@ 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.
-               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
-               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
+               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.
                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 is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
-               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
+               associated with the given target proxy. This field can only be set for global target proxies.
                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.
@@ -405,8 +399,7 @@ 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.
-        Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
-        For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
+        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.
         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}`
         """
@@ -421,8 +414,7 @@ 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 is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
-        For INTERNAL_MANAGED, use certificate_manager_certificates instead.
+        associated with the given target proxy. This field can only be set for global target proxies.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         """
         return pulumi.get(self, "certificate_map")
@@ -878,13 +870,11 @@ 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.
-               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
-               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
+               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.
                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 is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
-               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
+               associated with the given target proxy. This field can only be set for global target proxies.
                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,
@@ -1258,13 +1248,11 @@ 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.
-               Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
-               For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
+               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.
                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 is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
-               For INTERNAL_MANAGED, use certificate_manager_certificates instead.
+               associated with the given target proxy. This field can only be set for global target proxies.
                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.
@@ -1340,8 +1328,7 @@ 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.
-        Certificate manager certificates only apply when the load balancing scheme is set to INTERNAL_MANAGED.
-        For EXTERNAL and EXTERNAL_MANAGED, use certificate_map instead.
+        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.
         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}`
         """
@@ -1352,8 +1339,7 @@ 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 is only supported for EXTERNAL and EXTERNAL_MANAGED load balancing schemes.
-        For INTERNAL_MANAGED, use certificate_manager_certificates instead.
+        associated with the given target proxy. This field can only be set for global target proxies.
         Accepted format is `//certificatemanager.googleapis.com/projects/{project}/locations/{location}/certificateMaps/{resourceName}`.
         """
         return pulumi.get(self, "certificate_map")

pulumi_gcp/config/__init__.pyi

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

pulumi_gcp/config/vars.py

@@ -456,10 +456,6 @@ 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`, `BASIC`, and `ENTERPRISE`.
+        :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] 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`, `BASIC`, and `ENTERPRISE`.
+        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED` and `BASIC`.
         """
         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`, `BASIC`, and `ENTERPRISE`.
+        :param str mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED` and `BASIC`.
         :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`, `BASIC`, and `ENTERPRISE`.
+        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include `DISABLED` and `BASIC`.
         """
         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, BASIC, and ENTERPRISE.
+        :param str mode: Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include DISABLED and BASIC.
         :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, BASIC, and ENTERPRISE.
+        Sets the mode of the Kubernetes security posture API's off-cluster features. Available options include DISABLED and BASIC.
         """
         return pulumi.get(self, "mode")
 

pulumi_gcp/discoveryengine/_inputs.py

@@ -14,13 +14,6 @@ __all__ = [
     'ChatEngineChatEngineConfigAgentCreationConfigArgs',
     'ChatEngineChatEngineMetadataArgs',
     'ChatEngineCommonConfigArgs',
-    'DataStoreDocumentProcessingConfigArgs',
-    'DataStoreDocumentProcessingConfigDefaultParsingConfigArgs',
-    'DataStoreDocumentProcessingConfigDefaultParsingConfigDigitalParsingConfigArgs',
-    'DataStoreDocumentProcessingConfigDefaultParsingConfigOcrParsingConfigArgs',
-    'DataStoreDocumentProcessingConfigParsingConfigOverrideArgs',
-    'DataStoreDocumentProcessingConfigParsingConfigOverrideDigitalParsingConfigArgs',
-    'DataStoreDocumentProcessingConfigParsingConfigOverrideOcrParsingConfigArgs',
     'SearchEngineCommonConfigArgs',
     'SearchEngineSearchEngineConfigArgs',
 ]
@@ -170,226 +163,6 @@ 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__, *,