pulumi-gcp 7.17.0a1712402830__py3-none-any.whl → 7.17.0a1712602552__py3-none-any.whl

pulumi_gcp/bigquery/_inputs.py

@@ -4105,6 +4105,7 @@ 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,
@@ -4148,6 +4149,7 @@ 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
@@ -4195,6 +4197,8 @@ 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:
@@ -4356,6 +4360,18 @@ 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,6 +4303,8 @@ 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":
@@ -4340,6 +4342,7 @@ 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,
@@ -4383,6 +4386,7 @@ 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
@@ -4430,6 +4434,8 @@ 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:
@@ -4551,6 +4557,14 @@ 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,6 +21,7 @@ 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,
@@ -43,6 +44,8 @@ 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`.
@@ -76,6 +79,8 @@ 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:
@@ -161,6 +166,19 @@ 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]]:
@@ -292,6 +310,7 @@ 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,
@@ -312,6 +331,8 @@ 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.
@@ -354,6 +375,8 @@ 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:
@@ -409,6 +432,19 @@ 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]]:
@@ -607,6 +643,7 @@ 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,
@@ -809,6 +846,28 @@ 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 -->
@@ -866,6 +925,8 @@ 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.
@@ -1096,6 +1157,28 @@ 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 -->
@@ -1165,6 +1248,7 @@ 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,
@@ -1188,6 +1272,7 @@ 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
@@ -1223,6 +1308,7 @@ 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,
@@ -1248,6 +1334,8 @@ 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.
@@ -1292,6 +1380,7 @@ 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
@@ -1326,6 +1415,15 @@ 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/billing/project_info.py

@@ -141,8 +141,8 @@ class ProjectInfo(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         project = gcp.organizations.Project("project",
-            project_id="tf-test_77884",
-            name="tf-test_15222",
+            project_id="tf-test_15222",
+            name="tf-test_81126",
             org_id="123456789")
         default = gcp.billing.ProjectInfo("default",
             project=project.project_id,
@@ -204,8 +204,8 @@ class ProjectInfo(pulumi.CustomResource):
         import pulumi_gcp as gcp
 
         project = gcp.organizations.Project("project",
-            project_id="tf-test_77884",
-            name="tf-test_15222",
+            project_id="tf-test_15222",
+            name="tf-test_81126",
             org_id="123456789")
         default = gcp.billing.ProjectInfo("default",
             project=project.project_id,

pulumi_gcp/cloudquota/__init__.py

@@ -7,4 +7,6 @@ import typing
 # Export this package's modules as members:
 from .get_s_quota_info import *
 from .get_s_quota_infos import *
+from .s_quota_preference import *
+from ._inputs import *
 from . import outputs

pulumi_gcp/cloudquota/_inputs.py

@@ -0,0 +1,131 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+from .. import _utilities
+
+__all__ = [
+    'SQuotaPreferenceQuotaConfigArgs',
+]
+
+@pulumi.input_type
+class SQuotaPreferenceQuotaConfigArgs:
+    def __init__(__self__, *,
+                 preferred_value: pulumi.Input[str],
+                 annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 granted_value: Optional[pulumi.Input[str]] = None,
+                 request_origin: Optional[pulumi.Input[str]] = None,
+                 state_detail: Optional[pulumi.Input[str]] = None,
+                 trace_id: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] preferred_value: The preferred value. Must be greater than or equal to -1. If set to -1, it means the value is "unlimited".
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] annotations: The annotations map for clients to store small amounts of arbitrary data. Do not put PII or other sensitive information here. See https://google.aip.dev/128#annotations.
+               An object containing a list of "key: value" pairs. Example: `{ "name": "wrench", "mass": "1.3kg", "count": "3" }`.
+        :param pulumi.Input[str] granted_value: (Output)
+               Granted quota value.
+        :param pulumi.Input[str] request_origin: (Output)
+               The origin of the quota preference request.
+               
+               - - -
+        :param pulumi.Input[str] state_detail: (Output)
+               Optional details about the state of this quota preference.
+        :param pulumi.Input[str] trace_id: (Output)
+               The trace id that the Google Cloud uses to provision the requested quota. This trace id may be used by the client to contact Cloud support to track the state of a quota preference request. The trace id is only produced for increase requests and is unique for each request. The quota decrease requests do not have a trace id.
+        """
+        pulumi.set(__self__, "preferred_value", preferred_value)
+        if annotations is not None:
+            pulumi.set(__self__, "annotations", annotations)
+        if granted_value is not None:
+            pulumi.set(__self__, "granted_value", granted_value)
+        if request_origin is not None:
+            pulumi.set(__self__, "request_origin", request_origin)
+        if state_detail is not None:
+            pulumi.set(__self__, "state_detail", state_detail)
+        if trace_id is not None:
+            pulumi.set(__self__, "trace_id", trace_id)
+
+    @property
+    @pulumi.getter(name="preferredValue")
+    def preferred_value(self) -> pulumi.Input[str]:
+        """
+        The preferred value. Must be greater than or equal to -1. If set to -1, it means the value is "unlimited".
+        """
+        return pulumi.get(self, "preferred_value")
+
+    @preferred_value.setter
+    def preferred_value(self, value: pulumi.Input[str]):
+        pulumi.set(self, "preferred_value", value)
+
+    @property
+    @pulumi.getter
+    def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
+        """
+        The annotations map for clients to store small amounts of arbitrary data. Do not put PII or other sensitive information here. See https://google.aip.dev/128#annotations.
+        An object containing a list of "key: value" pairs. Example: `{ "name": "wrench", "mass": "1.3kg", "count": "3" }`.
+        """
+        return pulumi.get(self, "annotations")
+
+    @annotations.setter
+    def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "annotations", value)
+
+    @property
+    @pulumi.getter(name="grantedValue")
+    def granted_value(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        Granted quota value.
+        """
+        return pulumi.get(self, "granted_value")
+
+    @granted_value.setter
+    def granted_value(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "granted_value", value)
+
+    @property
+    @pulumi.getter(name="requestOrigin")
+    def request_origin(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The origin of the quota preference request.
+
+        - - -
+        """
+        return pulumi.get(self, "request_origin")
+
+    @request_origin.setter
+    def request_origin(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "request_origin", value)
+
+    @property
+    @pulumi.getter(name="stateDetail")
+    def state_detail(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        Optional details about the state of this quota preference.
+        """
+        return pulumi.get(self, "state_detail")
+
+    @state_detail.setter
+    def state_detail(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "state_detail", value)
+
+    @property
+    @pulumi.getter(name="traceId")
+    def trace_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The trace id that the Google Cloud uses to provision the requested quota. This trace id may be used by the client to contact Cloud support to track the state of a quota preference request. The trace id is only produced for increase requests and is unique for each request. The quota decrease requests do not have a trace id.
+        """
+        return pulumi.get(self, "trace_id")
+
+    @trace_id.setter
+    def trace_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "trace_id", value)
+
+

pulumi_gcp/cloudquota/outputs.py

@@ -11,6 +11,7 @@ from .. import _utilities
 from . import outputs
 
 __all__ = [
+    'SQuotaPreferenceQuotaConfig',
     'GetSQuotaInfoDimensionsInfoResult',
     'GetSQuotaInfoDimensionsInfoDetailResult',
     'GetSQuotaInfoQuotaIncreaseEligibilityResult',
@@ -20,6 +21,123 @@ __all__ = [
     'GetSQuotaInfosQuotaInfoQuotaIncreaseEligibilityResult',
 ]
 
+@pulumi.output_type
+class SQuotaPreferenceQuotaConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "preferredValue":
+            suggest = "preferred_value"
+        elif key == "grantedValue":
+            suggest = "granted_value"
+        elif key == "requestOrigin":
+            suggest = "request_origin"
+        elif key == "stateDetail":
+            suggest = "state_detail"
+        elif key == "traceId":
+            suggest = "trace_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SQuotaPreferenceQuotaConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SQuotaPreferenceQuotaConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SQuotaPreferenceQuotaConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 preferred_value: str,
+                 annotations: Optional[Mapping[str, str]] = None,
+                 granted_value: Optional[str] = None,
+                 request_origin: Optional[str] = None,
+                 state_detail: Optional[str] = None,
+                 trace_id: Optional[str] = None):
+        """
+        :param str preferred_value: The preferred value. Must be greater than or equal to -1. If set to -1, it means the value is "unlimited".
+        :param Mapping[str, str] annotations: The annotations map for clients to store small amounts of arbitrary data. Do not put PII or other sensitive information here. See https://google.aip.dev/128#annotations.
+               An object containing a list of "key: value" pairs. Example: `{ "name": "wrench", "mass": "1.3kg", "count": "3" }`.
+        :param str granted_value: (Output)
+               Granted quota value.
+        :param str request_origin: (Output)
+               The origin of the quota preference request.
+               
+               - - -
+        :param str state_detail: (Output)
+               Optional details about the state of this quota preference.
+        :param str trace_id: (Output)
+               The trace id that the Google Cloud uses to provision the requested quota. This trace id may be used by the client to contact Cloud support to track the state of a quota preference request. The trace id is only produced for increase requests and is unique for each request. The quota decrease requests do not have a trace id.
+        """
+        pulumi.set(__self__, "preferred_value", preferred_value)
+        if annotations is not None:
+            pulumi.set(__self__, "annotations", annotations)
+        if granted_value is not None:
+            pulumi.set(__self__, "granted_value", granted_value)
+        if request_origin is not None:
+            pulumi.set(__self__, "request_origin", request_origin)
+        if state_detail is not None:
+            pulumi.set(__self__, "state_detail", state_detail)
+        if trace_id is not None:
+            pulumi.set(__self__, "trace_id", trace_id)
+
+    @property
+    @pulumi.getter(name="preferredValue")
+    def preferred_value(self) -> str:
+        """
+        The preferred value. Must be greater than or equal to -1. If set to -1, it means the value is "unlimited".
+        """
+        return pulumi.get(self, "preferred_value")
+
+    @property
+    @pulumi.getter
+    def annotations(self) -> Optional[Mapping[str, str]]:
+        """
+        The annotations map for clients to store small amounts of arbitrary data. Do not put PII or other sensitive information here. See https://google.aip.dev/128#annotations.
+        An object containing a list of "key: value" pairs. Example: `{ "name": "wrench", "mass": "1.3kg", "count": "3" }`.
+        """
+        return pulumi.get(self, "annotations")
+
+    @property
+    @pulumi.getter(name="grantedValue")
+    def granted_value(self) -> Optional[str]:
+        """
+        (Output)
+        Granted quota value.
+        """
+        return pulumi.get(self, "granted_value")
+
+    @property
+    @pulumi.getter(name="requestOrigin")
+    def request_origin(self) -> Optional[str]:
+        """
+        (Output)
+        The origin of the quota preference request.
+
+        - - -
+        """
+        return pulumi.get(self, "request_origin")
+
+    @property
+    @pulumi.getter(name="stateDetail")
+    def state_detail(self) -> Optional[str]:
+        """
+        (Output)
+        Optional details about the state of this quota preference.
+        """
+        return pulumi.get(self, "state_detail")
+
+    @property
+    @pulumi.getter(name="traceId")
+    def trace_id(self) -> Optional[str]:
+        """
+        (Output)
+        The trace id that the Google Cloud uses to provision the requested quota. This trace id may be used by the client to contact Cloud support to track the state of a quota preference request. The trace id is only produced for increase requests and is unique for each request. The quota decrease requests do not have a trace id.
+        """
+        return pulumi.get(self, "trace_id")
+
+
 @pulumi.output_type
 class GetSQuotaInfoDimensionsInfoResult(dict):
     def __init__(__self__, *,