pulumi-gcp 7.17.0__py3-none-any.whl → 7.17.0a1711740254__py3-none-any.whl

pulumi_gcp/__init__.py

@@ -26,8 +26,6 @@ if typing.TYPE_CHECKING:
     appengine = __appengine
     import pulumi_gcp.apphub as __apphub
     apphub = __apphub
-    import pulumi_gcp.applicationintegration as __applicationintegration
-    applicationintegration = __applicationintegration
     import pulumi_gcp.artifactregistry as __artifactregistry
     artifactregistry = __artifactregistry
     import pulumi_gcp.assuredworkloads as __assuredworkloads
@@ -253,7 +251,6 @@ else:
     apigee = _utilities.lazy_import('pulumi_gcp.apigee')
     appengine = _utilities.lazy_import('pulumi_gcp.appengine')
     apphub = _utilities.lazy_import('pulumi_gcp.apphub')
-    applicationintegration = _utilities.lazy_import('pulumi_gcp.applicationintegration')
     artifactregistry = _utilities.lazy_import('pulumi_gcp.artifactregistry')
     assuredworkloads = _utilities.lazy_import('pulumi_gcp.assuredworkloads')
     backupdisasterrecovery = _utilities.lazy_import('pulumi_gcp.backupdisasterrecovery')
@@ -926,14 +923,6 @@ _utilities.register(
    "gcp:apphub/workload:Workload": "Workload"
   }
  },
- {
-  "pkg": "gcp",
-  "mod": "applicationintegration/client",
-  "fqn": "pulumi_gcp.applicationintegration",
-  "classes": {
-   "gcp:applicationintegration/client:Client": "Client"
-  }
- },
  {
   "pkg": "gcp",
   "mod": "artifactregistry/repository",
@@ -1886,14 +1875,6 @@ _utilities.register(
    "gcp:cloudids/endpoint:Endpoint": "Endpoint"
   }
  },
- {
-  "pkg": "gcp",
-  "mod": "cloudquota/sQuotaPreference",
-  "fqn": "pulumi_gcp.cloudquota",
-  "classes": {
-   "gcp:cloudquota/sQuotaPreference:SQuotaPreference": "SQuotaPreference"
-  }
- },
  {
   "pkg": "gcp",
   "mod": "cloudrun/domainMapping",
@@ -7214,14 +7195,6 @@ _utilities.register(
    "gcp:vertex/aiDataset:AiDataset": "AiDataset"
   }
  },
- {
-  "pkg": "gcp",
-  "mod": "vertex/aiDeploymentResourcePool",
-  "fqn": "pulumi_gcp.vertex",
-  "classes": {
-   "gcp:vertex/aiDeploymentResourcePool:AiDeploymentResourcePool": "AiDeploymentResourcePool"
-  }
- },
  {
   "pkg": "gcp",
   "mod": "vertex/aiEndpoint",

pulumi_gcp/apphub/__init__.py

@@ -6,7 +6,6 @@ from .. import _utilities
 import typing
 # Export this package's modules as members:
 from .application import *
-from .get_application import *
 from .get_discovered_service import *
 from .get_discovered_workload import *
 from .service import *

pulumi_gcp/apphub/outputs.py

@@ -34,13 +34,6 @@ __all__ = [
     'WorkloadAttributesOperatorOwner',
     'WorkloadWorkloadProperty',
     'WorkloadWorkloadReference',
-    'GetApplicationAttributeResult',
-    'GetApplicationAttributeBusinessOwnerResult',
-    'GetApplicationAttributeCriticalityResult',
-    'GetApplicationAttributeDeveloperOwnerResult',
-    'GetApplicationAttributeEnvironmentResult',
-    'GetApplicationAttributeOperatorOwnerResult',
-    'GetApplicationScopeResult',
     'GetDiscoveredServiceServicePropertyResult',
     'GetDiscoveredServiceServiceReferenceResult',
     'GetDiscoveredWorkloadWorkloadPropertyResult',
@@ -1084,213 +1077,6 @@ class WorkloadWorkloadReference(dict):
         return pulumi.get(self, "uri")
 
 
-@pulumi.output_type
-class GetApplicationAttributeResult(dict):
-    def __init__(__self__, *,
-                 business_owners: Sequence['outputs.GetApplicationAttributeBusinessOwnerResult'],
-                 criticalities: Sequence['outputs.GetApplicationAttributeCriticalityResult'],
-                 developer_owners: Sequence['outputs.GetApplicationAttributeDeveloperOwnerResult'],
-                 environments: Sequence['outputs.GetApplicationAttributeEnvironmentResult'],
-                 operator_owners: Sequence['outputs.GetApplicationAttributeOperatorOwnerResult']):
-        """
-        :param Sequence['GetApplicationAttributeBusinessOwnerArgs'] business_owners: Optional. Business team that ensures user needs are met and value is delivered
-        :param Sequence['GetApplicationAttributeCriticalityArgs'] criticalities: Criticality of the Application, Service, or Workload
-        :param Sequence['GetApplicationAttributeDeveloperOwnerArgs'] developer_owners: Optional. Developer team that owns development and coding.
-        :param Sequence['GetApplicationAttributeEnvironmentArgs'] environments: Environment of the Application, Service, or Workload
-        :param Sequence['GetApplicationAttributeOperatorOwnerArgs'] operator_owners: Optional. Operator team that ensures runtime and operations.
-        """
-        pulumi.set(__self__, "business_owners", business_owners)
-        pulumi.set(__self__, "criticalities", criticalities)
-        pulumi.set(__self__, "developer_owners", developer_owners)
-        pulumi.set(__self__, "environments", environments)
-        pulumi.set(__self__, "operator_owners", operator_owners)
-
-    @property
-    @pulumi.getter(name="businessOwners")
-    def business_owners(self) -> Sequence['outputs.GetApplicationAttributeBusinessOwnerResult']:
-        """
-        Optional. Business team that ensures user needs are met and value is delivered
-        """
-        return pulumi.get(self, "business_owners")
-
-    @property
-    @pulumi.getter
-    def criticalities(self) -> Sequence['outputs.GetApplicationAttributeCriticalityResult']:
-        """
-        Criticality of the Application, Service, or Workload
-        """
-        return pulumi.get(self, "criticalities")
-
-    @property
-    @pulumi.getter(name="developerOwners")
-    def developer_owners(self) -> Sequence['outputs.GetApplicationAttributeDeveloperOwnerResult']:
-        """
-        Optional. Developer team that owns development and coding.
-        """
-        return pulumi.get(self, "developer_owners")
-
-    @property
-    @pulumi.getter
-    def environments(self) -> Sequence['outputs.GetApplicationAttributeEnvironmentResult']:
-        """
-        Environment of the Application, Service, or Workload
-        """
-        return pulumi.get(self, "environments")
-
-    @property
-    @pulumi.getter(name="operatorOwners")
-    def operator_owners(self) -> Sequence['outputs.GetApplicationAttributeOperatorOwnerResult']:
-        """
-        Optional. Operator team that ensures runtime and operations.
-        """
-        return pulumi.get(self, "operator_owners")
-
-
-@pulumi.output_type
-class GetApplicationAttributeBusinessOwnerResult(dict):
-    def __init__(__self__, *,
-                 display_name: str,
-                 email: str):
-        """
-        :param str display_name: Optional. Contact's name.
-        :param str email: Required. Email address of the contacts.
-        """
-        pulumi.set(__self__, "display_name", display_name)
-        pulumi.set(__self__, "email", email)
-
-    @property
-    @pulumi.getter(name="displayName")
-    def display_name(self) -> str:
-        """
-        Optional. Contact's name.
-        """
-        return pulumi.get(self, "display_name")
-
-    @property
-    @pulumi.getter
-    def email(self) -> str:
-        """
-        Required. Email address of the contacts.
-        """
-        return pulumi.get(self, "email")
-
-
-@pulumi.output_type
-class GetApplicationAttributeCriticalityResult(dict):
-    def __init__(__self__, *,
-                 type: str):
-        """
-        :param str type: Criticality type. Possible values: ["MISSION_CRITICAL", "HIGH", "MEDIUM", "LOW"]
-        """
-        pulumi.set(__self__, "type", type)
-
-    @property
-    @pulumi.getter
-    def type(self) -> str:
-        """
-        Criticality type. Possible values: ["MISSION_CRITICAL", "HIGH", "MEDIUM", "LOW"]
-        """
-        return pulumi.get(self, "type")
-
-
-@pulumi.output_type
-class GetApplicationAttributeDeveloperOwnerResult(dict):
-    def __init__(__self__, *,
-                 display_name: str,
-                 email: str):
-        """
-        :param str display_name: Optional. Contact's name.
-        :param str email: Required. Email address of the contacts.
-        """
-        pulumi.set(__self__, "display_name", display_name)
-        pulumi.set(__self__, "email", email)
-
-    @property
-    @pulumi.getter(name="displayName")
-    def display_name(self) -> str:
-        """
-        Optional. Contact's name.
-        """
-        return pulumi.get(self, "display_name")
-
-    @property
-    @pulumi.getter
-    def email(self) -> str:
-        """
-        Required. Email address of the contacts.
-        """
-        return pulumi.get(self, "email")
-
-
-@pulumi.output_type
-class GetApplicationAttributeEnvironmentResult(dict):
-    def __init__(__self__, *,
-                 type: str):
-        """
-        :param str type: Environment type. Possible values: ["PRODUCTION", "STAGING", "TEST", "DEVELOPMENT"]
-        """
-        pulumi.set(__self__, "type", type)
-
-    @property
-    @pulumi.getter
-    def type(self) -> str:
-        """
-        Environment type. Possible values: ["PRODUCTION", "STAGING", "TEST", "DEVELOPMENT"]
-        """
-        return pulumi.get(self, "type")
-
-
-@pulumi.output_type
-class GetApplicationAttributeOperatorOwnerResult(dict):
-    def __init__(__self__, *,
-                 display_name: str,
-                 email: str):
-        """
-        :param str display_name: Optional. Contact's name.
-        :param str email: Required. Email address of the contacts.
-        """
-        pulumi.set(__self__, "display_name", display_name)
-        pulumi.set(__self__, "email", email)
-
-    @property
-    @pulumi.getter(name="displayName")
-    def display_name(self) -> str:
-        """
-        Optional. Contact's name.
-        """
-        return pulumi.get(self, "display_name")
-
-    @property
-    @pulumi.getter
-    def email(self) -> str:
-        """
-        Required. Email address of the contacts.
-        """
-        return pulumi.get(self, "email")
-
-
-@pulumi.output_type
-class GetApplicationScopeResult(dict):
-    def __init__(__self__, *,
-                 type: str):
-        """
-        :param str type: Required. Scope Type. 
-                Possible values:
-               REGIONAL Possible values: ["REGIONAL"]
-        """
-        pulumi.set(__self__, "type", type)
-
-    @property
-    @pulumi.getter
-    def type(self) -> str:
-        """
-        Required. Scope Type. 
-         Possible values:
-        REGIONAL Possible values: ["REGIONAL"]
-        """
-        return pulumi.get(self, "type")
-
-
 @pulumi.output_type
 class GetDiscoveredServiceServicePropertyResult(dict):
     def __init__(__self__, *,

pulumi_gcp/bigquery/_inputs.py

@@ -4105,7 +4105,6 @@ class TableExternalDataConfigurationArgs:
                  google_sheets_options: Optional[pulumi.Input['TableExternalDataConfigurationGoogleSheetsOptionsArgs']] = None,
                  hive_partitioning_options: Optional[pulumi.Input['TableExternalDataConfigurationHivePartitioningOptionsArgs']] = None,
                  ignore_unknown_values: Optional[pulumi.Input[bool]] = None,
-                 json_extension: Optional[pulumi.Input[str]] = None,
                  json_options: Optional[pulumi.Input['TableExternalDataConfigurationJsonOptionsArgs']] = None,
                  max_bad_records: Optional[pulumi.Input[int]] = None,
                  metadata_cache_mode: Optional[pulumi.Input[str]] = None,
@@ -4149,7 +4148,6 @@ class TableExternalDataConfigurationArgs:
                extra columns are treated as bad records, and if there are too
                many bad records, an invalid error is returned in the job result.
                The default value is false.
-        :param pulumi.Input[str] json_extension: Used to indicate that a JSON variant, rather than normal JSON, is being used as the sourceFormat. This should only be used in combination with the `JSON` source format. Valid values are: `GEOJSON`.
         :param pulumi.Input['TableExternalDataConfigurationJsonOptionsArgs'] json_options: Additional properties to set if
                `source_format` is set to "JSON". Structure is documented below.
         :param pulumi.Input[int] max_bad_records: The maximum number of bad records that
@@ -4197,8 +4195,6 @@ class TableExternalDataConfigurationArgs:
             pulumi.set(__self__, "hive_partitioning_options", hive_partitioning_options)
         if ignore_unknown_values is not None:
             pulumi.set(__self__, "ignore_unknown_values", ignore_unknown_values)
-        if json_extension is not None:
-            pulumi.set(__self__, "json_extension", json_extension)
         if json_options is not None:
             pulumi.set(__self__, "json_options", json_options)
         if max_bad_records is not None:
@@ -4360,18 +4356,6 @@ class TableExternalDataConfigurationArgs:
     def ignore_unknown_values(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "ignore_unknown_values", value)
 
-    @property
-    @pulumi.getter(name="jsonExtension")
-    def json_extension(self) -> Optional[pulumi.Input[str]]:
-        """
-        Used to indicate that a JSON variant, rather than normal JSON, is being used as the sourceFormat. This should only be used in combination with the `JSON` source format. Valid values are: `GEOJSON`.
-        """
-        return pulumi.get(self, "json_extension")
-
-    @json_extension.setter
-    def json_extension(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "json_extension", value)
-
     @property
     @pulumi.getter(name="jsonOptions")
     def json_options(self) -> Optional[pulumi.Input['TableExternalDataConfigurationJsonOptionsArgs']]:

pulumi_gcp/bigquery/outputs.py

@@ -4303,8 +4303,6 @@ class TableExternalDataConfiguration(dict):
             suggest = "hive_partitioning_options"
         elif key == "ignoreUnknownValues":
             suggest = "ignore_unknown_values"
-        elif key == "jsonExtension":
-            suggest = "json_extension"
         elif key == "jsonOptions":
             suggest = "json_options"
         elif key == "maxBadRecords":
@@ -4342,7 +4340,6 @@ class TableExternalDataConfiguration(dict):
                  google_sheets_options: Optional['outputs.TableExternalDataConfigurationGoogleSheetsOptions'] = None,
                  hive_partitioning_options: Optional['outputs.TableExternalDataConfigurationHivePartitioningOptions'] = None,
                  ignore_unknown_values: Optional[bool] = None,
-                 json_extension: Optional[str] = None,
                  json_options: Optional['outputs.TableExternalDataConfigurationJsonOptions'] = None,
                  max_bad_records: Optional[int] = None,
                  metadata_cache_mode: Optional[str] = None,
@@ -4386,7 +4383,6 @@ class TableExternalDataConfiguration(dict):
                extra columns are treated as bad records, and if there are too
                many bad records, an invalid error is returned in the job result.
                The default value is false.
-        :param str json_extension: Used to indicate that a JSON variant, rather than normal JSON, is being used as the sourceFormat. This should only be used in combination with the `JSON` source format. Valid values are: `GEOJSON`.
         :param 'TableExternalDataConfigurationJsonOptionsArgs' json_options: Additional properties to set if
                `source_format` is set to "JSON". Structure is documented below.
         :param int max_bad_records: The maximum number of bad records that
@@ -4434,8 +4430,6 @@ class TableExternalDataConfiguration(dict):
             pulumi.set(__self__, "hive_partitioning_options", hive_partitioning_options)
         if ignore_unknown_values is not None:
             pulumi.set(__self__, "ignore_unknown_values", ignore_unknown_values)
-        if json_extension is not None:
-            pulumi.set(__self__, "json_extension", json_extension)
         if json_options is not None:
             pulumi.set(__self__, "json_options", json_options)
         if max_bad_records is not None:
@@ -4557,14 +4551,6 @@ class TableExternalDataConfiguration(dict):
         """
         return pulumi.get(self, "ignore_unknown_values")
 
-    @property
-    @pulumi.getter(name="jsonExtension")
-    def json_extension(self) -> Optional[str]:
-        """
-        Used to indicate that a JSON variant, rather than normal JSON, is being used as the sourceFormat. This should only be used in combination with the `JSON` source format. Valid values are: `GEOJSON`.
-        """
-        return pulumi.get(self, "json_extension")
-
     @property
     @pulumi.getter(name="jsonOptions")
     def json_options(self) -> Optional['outputs.TableExternalDataConfigurationJsonOptions']:

pulumi_gcp/bigquery/routine.py

@@ -21,7 +21,6 @@ class RoutineArgs:
                  routine_id: pulumi.Input[str],
                  routine_type: pulumi.Input[str],
                  arguments: Optional[pulumi.Input[Sequence[pulumi.Input['RoutineArgumentArgs']]]] = None,
-                 data_governance_type: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  determinism_level: Optional[pulumi.Input[str]] = None,
                  imported_libraries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -44,8 +43,6 @@ class RoutineArgs:
                Possible values are: `SCALAR_FUNCTION`, `PROCEDURE`, `TABLE_VALUED_FUNCTION`.
         :param pulumi.Input[Sequence[pulumi.Input['RoutineArgumentArgs']]] arguments: Input/output argument of a function or a stored procedure.
                Structure is documented below.
-        :param pulumi.Input[str] data_governance_type: If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask
-               Possible values are: `DATA_MASKING`.
         :param pulumi.Input[str] description: The description of the routine if defined.
         :param pulumi.Input[str] determinism_level: The determinism level of the JavaScript UDF if defined.
                Possible values are: `DETERMINISM_LEVEL_UNSPECIFIED`, `DETERMINISTIC`, `NOT_DETERMINISTIC`.
@@ -79,8 +76,6 @@ class RoutineArgs:
         pulumi.set(__self__, "routine_type", routine_type)
         if arguments is not None:
             pulumi.set(__self__, "arguments", arguments)
-        if data_governance_type is not None:
-            pulumi.set(__self__, "data_governance_type", data_governance_type)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if determinism_level is not None:
@@ -166,19 +161,6 @@ class RoutineArgs:
     def arguments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RoutineArgumentArgs']]]]):
         pulumi.set(self, "arguments", value)
 
-    @property
-    @pulumi.getter(name="dataGovernanceType")
-    def data_governance_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask
-        Possible values are: `DATA_MASKING`.
-        """
-        return pulumi.get(self, "data_governance_type")
-
-    @data_governance_type.setter
-    def data_governance_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "data_governance_type", value)
-
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -310,7 +292,6 @@ class _RoutineState:
     def __init__(__self__, *,
                  arguments: Optional[pulumi.Input[Sequence[pulumi.Input['RoutineArgumentArgs']]]] = None,
                  creation_time: Optional[pulumi.Input[int]] = None,
-                 data_governance_type: Optional[pulumi.Input[str]] = None,
                  dataset_id: Optional[pulumi.Input[str]] = None,
                  definition_body: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -331,8 +312,6 @@ class _RoutineState:
                Structure is documented below.
         :param pulumi.Input[int] creation_time: The time when this routine was created, in milliseconds since the
                epoch.
-        :param pulumi.Input[str] data_governance_type: If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask
-               Possible values are: `DATA_MASKING`.
         :param pulumi.Input[str] dataset_id: The ID of the dataset containing this routine
         :param pulumi.Input[str] definition_body: The body of the routine. For functions, this is the expression in the AS clause.
                If language=SQL, it is the substring inside (but excluding) the parentheses.
@@ -375,8 +354,6 @@ class _RoutineState:
             pulumi.set(__self__, "arguments", arguments)
         if creation_time is not None:
             pulumi.set(__self__, "creation_time", creation_time)
-        if data_governance_type is not None:
-            pulumi.set(__self__, "data_governance_type", data_governance_type)
         if dataset_id is not None:
             pulumi.set(__self__, "dataset_id", dataset_id)
         if definition_body is not None:
@@ -432,19 +409,6 @@ class _RoutineState:
     def creation_time(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "creation_time", value)
 
-    @property
-    @pulumi.getter(name="dataGovernanceType")
-    def data_governance_type(self) -> Optional[pulumi.Input[str]]:
-        """
-        If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask
-        Possible values are: `DATA_MASKING`.
-        """
-        return pulumi.get(self, "data_governance_type")
-
-    @data_governance_type.setter
-    def data_governance_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "data_governance_type", value)
-
     @property
     @pulumi.getter(name="datasetId")
     def dataset_id(self) -> Optional[pulumi.Input[str]]:
@@ -643,7 +607,6 @@ class Routine(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  arguments: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RoutineArgumentArgs']]]]] = None,
-                 data_governance_type: Optional[pulumi.Input[str]] = None,
                  dataset_id: Optional[pulumi.Input[str]] = None,
                  definition_body: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -846,28 +809,6 @@ class Routine(pulumi.CustomResource):
             ))
         ```
         <!--End PulumiCodeChooser -->
-        ### Bigquery Routine Data Governance Type
-
-        <!--Start PulumiCodeChooser -->
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_77884")
-        custom_masking_routine = gcp.bigquery.Routine("custom_masking_routine",
-            dataset_id=test.dataset_id,
-            routine_id="custom_masking_routine",
-            routine_type="SCALAR_FUNCTION",
-            language="SQL",
-            data_governance_type="DATA_MASKING",
-            definition_body="SAFE.REGEXP_REPLACE(ssn, '[0-9]', 'X')",
-            arguments=[gcp.bigquery.RoutineArgumentArgs(
-                name="ssn",
-                data_type="{\\"typeKind\\" :  \\"STRING\\"}",
-            )],
-            return_type="{\\"typeKind\\" :  \\"STRING\\"}")
-        ```
-        <!--End PulumiCodeChooser -->
         ### Bigquery Routine Remote Function
 
         <!--Start PulumiCodeChooser -->
@@ -925,8 +866,6 @@ class Routine(pulumi.CustomResource):
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RoutineArgumentArgs']]]] arguments: Input/output argument of a function or a stored procedure.
                Structure is documented below.
-        :param pulumi.Input[str] data_governance_type: If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask
-               Possible values are: `DATA_MASKING`.
         :param pulumi.Input[str] dataset_id: The ID of the dataset containing this routine
         :param pulumi.Input[str] definition_body: The body of the routine. For functions, this is the expression in the AS clause.
                If language=SQL, it is the substring inside (but excluding) the parentheses.
@@ -1157,28 +1096,6 @@ class Routine(pulumi.CustomResource):
             ))
         ```
         <!--End PulumiCodeChooser -->
-        ### Bigquery Routine Data Governance Type
-
-        <!--Start PulumiCodeChooser -->
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        test = gcp.bigquery.Dataset("test", dataset_id="tf_test_dataset_id_77884")
-        custom_masking_routine = gcp.bigquery.Routine("custom_masking_routine",
-            dataset_id=test.dataset_id,
-            routine_id="custom_masking_routine",
-            routine_type="SCALAR_FUNCTION",
-            language="SQL",
-            data_governance_type="DATA_MASKING",
-            definition_body="SAFE.REGEXP_REPLACE(ssn, '[0-9]', 'X')",
-            arguments=[gcp.bigquery.RoutineArgumentArgs(
-                name="ssn",
-                data_type="{\\"typeKind\\" :  \\"STRING\\"}",
-            )],
-            return_type="{\\"typeKind\\" :  \\"STRING\\"}")
-        ```
-        <!--End PulumiCodeChooser -->
         ### Bigquery Routine Remote Function
 
         <!--Start PulumiCodeChooser -->
@@ -1248,7 +1165,6 @@ class Routine(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  arguments: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RoutineArgumentArgs']]]]] = None,
-                 data_governance_type: Optional[pulumi.Input[str]] = None,
                  dataset_id: Optional[pulumi.Input[str]] = None,
                  definition_body: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -1272,7 +1188,6 @@ class Routine(pulumi.CustomResource):
             __props__ = RoutineArgs.__new__(RoutineArgs)
 
             __props__.__dict__["arguments"] = arguments
-            __props__.__dict__["data_governance_type"] = data_governance_type
             if dataset_id is None and not opts.urn:
                 raise TypeError("Missing required property 'dataset_id'")
             __props__.__dict__["dataset_id"] = dataset_id
@@ -1308,7 +1223,6 @@ class Routine(pulumi.CustomResource):
             opts: Optional[pulumi.ResourceOptions] = None,
             arguments: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RoutineArgumentArgs']]]]] = None,
             creation_time: Optional[pulumi.Input[int]] = None,
-            data_governance_type: Optional[pulumi.Input[str]] = None,
             dataset_id: Optional[pulumi.Input[str]] = None,
             definition_body: Optional[pulumi.Input[str]] = None,
             description: Optional[pulumi.Input[str]] = None,
@@ -1334,8 +1248,6 @@ class Routine(pulumi.CustomResource):
                Structure is documented below.
         :param pulumi.Input[int] creation_time: The time when this routine was created, in milliseconds since the
                epoch.
-        :param pulumi.Input[str] data_governance_type: If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask
-               Possible values are: `DATA_MASKING`.
         :param pulumi.Input[str] dataset_id: The ID of the dataset containing this routine
         :param pulumi.Input[str] definition_body: The body of the routine. For functions, this is the expression in the AS clause.
                If language=SQL, it is the substring inside (but excluding) the parentheses.
@@ -1380,7 +1292,6 @@ class Routine(pulumi.CustomResource):
 
         __props__.__dict__["arguments"] = arguments
         __props__.__dict__["creation_time"] = creation_time
-        __props__.__dict__["data_governance_type"] = data_governance_type
         __props__.__dict__["dataset_id"] = dataset_id
         __props__.__dict__["definition_body"] = definition_body
         __props__.__dict__["description"] = description
@@ -1415,15 +1326,6 @@ class Routine(pulumi.CustomResource):
         """
         return pulumi.get(self, "creation_time")
 
-    @property
-    @pulumi.getter(name="dataGovernanceType")
-    def data_governance_type(self) -> pulumi.Output[Optional[str]]:
-        """
-        If set to DATA_MASKING, the function is validated and made available as a masking function. For more information, see https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask
-        Possible values are: `DATA_MASKING`.
-        """
-        return pulumi.get(self, "data_governance_type")
-
     @property
     @pulumi.getter(name="datasetId")
     def dataset_id(self) -> pulumi.Output[str]:

pulumi_gcp/bigtable/_inputs.py

@@ -122,8 +122,8 @@ class InstanceClusterArgs:
                `bigtable.Instance` resource. If these values are changing, use a new
                `cluster_id`.
         :param pulumi.Input[int] num_nodes: The number of nodes in the cluster.
-               If no value is set, Cloud Bigtable automatically allocates nodes based on your data footprint and optimized for 50% storage utilization.
-        :param pulumi.Input[str] state: describes the current state of the cluster.
+               If no value is set, Cloud Bigtable automatically allocates nodes based on your data footprint and optimized for 50%!s(MISSING)torage utilization.
+        :param pulumi.Input[str] state: The state of the cluster
         :param pulumi.Input[str] storage_type: The storage type to use. One of `"SSD"` or
                `"HDD"`. Defaults to `"SSD"`.
         :param pulumi.Input[str] zone: The zone to create the Cloud Bigtable cluster in. If it not
@@ -194,7 +194,7 @@ class InstanceClusterArgs:
     def num_nodes(self) -> Optional[pulumi.Input[int]]:
         """
         The number of nodes in the cluster.
-        If no value is set, Cloud Bigtable automatically allocates nodes based on your data footprint and optimized for 50% storage utilization.
+        If no value is set, Cloud Bigtable automatically allocates nodes based on your data footprint and optimized for 50%!s(MISSING)torage utilization.
         """
         return pulumi.get(self, "num_nodes")
 
@@ -206,7 +206,7 @@ class InstanceClusterArgs:
     @pulumi.getter
     def state(self) -> Optional[pulumi.Input[str]]:
         """
-        describes the current state of the cluster.
+        The state of the cluster
         """
         return pulumi.get(self, "state")
 

pulumi_gcp/bigtable/gc_policy.py

@@ -475,10 +475,6 @@ class GCPolicy(pulumi.CustomResource):
         <!--End PulumiCodeChooser -->
         This is equivalent to running the following `cbt` command:
 
-        ## Import
-
-        This resource does not support import.
-
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[str] column_family: The name of the column family.
@@ -628,10 +624,6 @@ class GCPolicy(pulumi.CustomResource):
         <!--End PulumiCodeChooser -->
         This is equivalent to running the following `cbt` command:
 
-        ## Import
-
-        This resource does not support import.
-
         :param str resource_name: The name of the resource.
         :param GCPolicyArgs args: The arguments to use to populate this resource's properties.
         :param pulumi.ResourceOptions opts: Options for the resource.