pulumi-gcp 8.28.0a1745598508__py3-none-any.whl → 8.29.0__py3-none-any.whl

pulumi_gcp/compute/_inputs.py

@@ -84,6 +84,8 @@ __all__ = [
     'BackendServiceLocalityLbPolicyPolicyArgsDict',
     'BackendServiceLogConfigArgs',
     'BackendServiceLogConfigArgsDict',
+    'BackendServiceMaxStreamDurationArgs',
+    'BackendServiceMaxStreamDurationArgsDict',
     'BackendServiceOutlierDetectionArgs',
     'BackendServiceOutlierDetectionArgsDict',
     'BackendServiceOutlierDetectionBaseEjectionTimeArgs',
@@ -1174,6 +1176,14 @@ __all__ = [
     'SnapshotSnapshotEncryptionKeyArgsDict',
     'SnapshotSourceDiskEncryptionKeyArgs',
     'SnapshotSourceDiskEncryptionKeyArgsDict',
+    'StoragePoolIamBindingConditionArgs',
+    'StoragePoolIamBindingConditionArgsDict',
+    'StoragePoolIamMemberConditionArgs',
+    'StoragePoolIamMemberConditionArgsDict',
+    'StoragePoolResourceStatusArgs',
+    'StoragePoolResourceStatusArgsDict',
+    'StoragePoolStatusArgs',
+    'StoragePoolStatusArgsDict',
     'SubnetworkIAMBindingConditionArgs',
     'SubnetworkIAMBindingConditionArgsDict',
     'SubnetworkIAMMemberConditionArgs',
@@ -2445,16 +2455,19 @@ if not MYPY:
         """
         client_ttl: NotRequired[pulumi.Input[builtins.int]]
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         default_ttl: NotRequired[pulumi.Input[builtins.int]]
         """
         Specifies the default TTL for cached content served by this origin for responses
-        that do not have an existing valid TTL (max-age or s-max-age).
+        that do not have an existing valid TTL (max-age or s-max-age). When the `cache_mode`
+        is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         max_ttl: NotRequired[pulumi.Input[builtins.int]]
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         negative_caching: NotRequired[pulumi.Input[builtins.bool]]
         """
@@ -2510,10 +2523,13 @@ class BackendBucketCdnPolicyArgs:
         :param pulumi.Input[builtins.str] cache_mode: Specifies the cache setting for all responses from this backend.
                The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
                Possible values are: `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, `CACHE_ALL_STATIC`.
-        :param pulumi.Input[builtins.int] client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
+        :param pulumi.Input[builtins.int] client_ttl: Specifies the maximum allowed TTL for cached content served by this origin. When the
+               `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         :param pulumi.Input[builtins.int] default_ttl: Specifies the default TTL for cached content served by this origin for responses
-               that do not have an existing valid TTL (max-age or s-max-age).
-        :param pulumi.Input[builtins.int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
+               that do not have an existing valid TTL (max-age or s-max-age). When the `cache_mode`
+               is set to "USE_ORIGIN_HEADERS", you must omit this field.
+        :param pulumi.Input[builtins.int] max_ttl: Specifies the maximum allowed TTL for cached content served by this origin. When the
+               `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         :param pulumi.Input[builtins.bool] negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
         :param pulumi.Input[Sequence[pulumi.Input['BackendBucketCdnPolicyNegativeCachingPolicyArgs']]] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
                Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
@@ -2596,7 +2612,8 @@ class BackendBucketCdnPolicyArgs:
     @pulumi.getter(name="clientTtl")
     def client_ttl(self) -> Optional[pulumi.Input[builtins.int]]:
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "client_ttl")
 
@@ -2609,7 +2626,8 @@ class BackendBucketCdnPolicyArgs:
     def default_ttl(self) -> Optional[pulumi.Input[builtins.int]]:
         """
         Specifies the default TTL for cached content served by this origin for responses
-        that do not have an existing valid TTL (max-age or s-max-age).
+        that do not have an existing valid TTL (max-age or s-max-age). When the `cache_mode`
+        is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "default_ttl")
 
@@ -2621,7 +2639,8 @@ class BackendBucketCdnPolicyArgs:
     @pulumi.getter(name="maxTtl")
     def max_ttl(self) -> Optional[pulumi.Input[builtins.int]]:
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "max_ttl")
 
@@ -3046,6 +3065,16 @@ if not MYPY:
         Used when balancingMode is UTILIZATION. This ratio defines the
         CPU utilization target for the group. Valid range is [0.0, 1.0].
         """
+        preference: NotRequired[pulumi.Input[builtins.str]]
+        """
+        This field indicates whether this backend should be fully utilized before sending traffic to backends
+        with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+        - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+        based on RTT.
+        - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+        traffic would be assigned based on the load balancing algorithm you use. This is the default
+        Possible values are: `PREFERRED`, `DEFAULT`.
+        """
 elif False:
     BackendServiceBackendArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -3063,7 +3092,8 @@ class BackendServiceBackendArgs:
                  max_rate: Optional[pulumi.Input[builtins.int]] = None,
                  max_rate_per_endpoint: Optional[pulumi.Input[builtins.float]] = None,
                  max_rate_per_instance: Optional[pulumi.Input[builtins.float]] = None,
-                 max_utilization: Optional[pulumi.Input[builtins.float]] = None):
+                 max_utilization: Optional[pulumi.Input[builtins.float]] = None,
+                 preference: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] group: The fully-qualified URL of an Instance Group or Network Endpoint
                Group resource. In case of instance group this defines the list
@@ -3129,6 +3159,13 @@ class BackendServiceBackendArgs:
                either maxRate or maxRatePerInstance must be set.
         :param pulumi.Input[builtins.float] max_utilization: Used when balancingMode is UTILIZATION. This ratio defines the
                CPU utilization target for the group. Valid range is [0.0, 1.0].
+        :param pulumi.Input[builtins.str] preference: This field indicates whether this backend should be fully utilized before sending traffic to backends
+               with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+               - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+               based on RTT.
+               - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+               traffic would be assigned based on the load balancing algorithm you use. This is the default
+               Possible values are: `PREFERRED`, `DEFAULT`.
         """
         pulumi.set(__self__, "group", group)
         if balancing_mode is not None:
@@ -3153,6 +3190,8 @@ class BackendServiceBackendArgs:
             pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
         if max_utilization is not None:
             pulumi.set(__self__, "max_utilization", max_utilization)
+        if preference is not None:
+            pulumi.set(__self__, "preference", preference)
 
     @property
     @pulumi.getter
@@ -3350,6 +3389,24 @@ class BackendServiceBackendArgs:
     def max_utilization(self, value: Optional[pulumi.Input[builtins.float]]):
         pulumi.set(self, "max_utilization", value)
 
+    @property
+    @pulumi.getter
+    def preference(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        This field indicates whether this backend should be fully utilized before sending traffic to backends
+        with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+        - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+        based on RTT.
+        - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+        traffic would be assigned based on the load balancing algorithm you use. This is the default
+        Possible values are: `PREFERRED`, `DEFAULT`.
+        """
+        return pulumi.get(self, "preference")
+
+    @preference.setter
+    def preference(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "preference", value)
+
 
 if not MYPY:
     class BackendServiceBackendCustomMetricArgsDict(TypedDict):
@@ -3490,6 +3547,11 @@ if not MYPY:
         Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
         Structure is documented below.
         """
+        request_coalescing: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+        to the origin.
+        """
         serve_while_stale: NotRequired[pulumi.Input[builtins.int]]
         """
         Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
@@ -3520,6 +3582,7 @@ class BackendServiceCdnPolicyArgs:
                  max_ttl: Optional[pulumi.Input[builtins.int]] = None,
                  negative_caching: Optional[pulumi.Input[builtins.bool]] = None,
                  negative_caching_policies: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]] = None,
+                 request_coalescing: Optional[pulumi.Input[builtins.bool]] = None,
                  serve_while_stale: Optional[pulumi.Input[builtins.int]] = None,
                  signed_url_cache_max_age_sec: Optional[pulumi.Input[builtins.int]] = None):
         """
@@ -3539,6 +3602,8 @@ class BackendServiceCdnPolicyArgs:
         :param pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
                Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
                Structure is documented below.
+        :param pulumi.Input[builtins.bool] request_coalescing: If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+               to the origin.
         :param pulumi.Input[builtins.int] serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
         :param pulumi.Input[builtins.int] signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request
                will be considered fresh, defaults to 1hr (3600s). After this
@@ -3566,6 +3631,8 @@ class BackendServiceCdnPolicyArgs:
             pulumi.set(__self__, "negative_caching", negative_caching)
         if negative_caching_policies is not None:
             pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
+        if request_coalescing is not None:
+            pulumi.set(__self__, "request_coalescing", request_coalescing)
         if serve_while_stale is not None:
             pulumi.set(__self__, "serve_while_stale", serve_while_stale)
         if signed_url_cache_max_age_sec is not None:
@@ -3675,6 +3742,19 @@ class BackendServiceCdnPolicyArgs:
     def negative_caching_policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCdnPolicyNegativeCachingPolicyArgs']]]]):
         pulumi.set(self, "negative_caching_policies", value)
 
+    @property
+    @pulumi.getter(name="requestCoalescing")
+    def request_coalescing(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+        to the origin.
+        """
+        return pulumi.get(self, "request_coalescing")
+
+    @request_coalescing.setter
+    def request_coalescing(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "request_coalescing", value)
+
     @property
     @pulumi.getter(name="serveWhileStale")
     def serve_while_stale(self) -> Optional[pulumi.Input[builtins.int]]:
@@ -4998,6 +5078,18 @@ if not MYPY:
         """
         Whether to enable logging for the load balancer traffic served by this backend service.
         """
+        optional_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
+        """
+        This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+        was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+        For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        """
+        optional_mode: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Specifies the optional logging mode for the load balancer traffic.
+        Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM.
+        Possible values are: `INCLUDE_ALL_OPTIONAL`, `EXCLUDE_ALL_OPTIONAL`, `CUSTOM`.
+        """
         sample_rate: NotRequired[pulumi.Input[builtins.float]]
         """
         This field can only be specified if logging is enabled for this backend service. The value of
@@ -5012,9 +5104,17 @@ elif False:
 class BackendServiceLogConfigArgs:
     def __init__(__self__, *,
                  enable: Optional[pulumi.Input[builtins.bool]] = None,
+                 optional_fields: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
+                 optional_mode: Optional[pulumi.Input[builtins.str]] = None,
                  sample_rate: Optional[pulumi.Input[builtins.float]] = None):
         """
         :param pulumi.Input[builtins.bool] enable: Whether to enable logging for the load balancer traffic served by this backend service.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] optional_fields: This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+               was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+               For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        :param pulumi.Input[builtins.str] optional_mode: Specifies the optional logging mode for the load balancer traffic.
+               Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM.
+               Possible values are: `INCLUDE_ALL_OPTIONAL`, `EXCLUDE_ALL_OPTIONAL`, `CUSTOM`.
         :param pulumi.Input[builtins.float] sample_rate: This field can only be specified if logging is enabled for this backend service. The value of
                the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
                where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
@@ -5022,6 +5122,10 @@ class BackendServiceLogConfigArgs:
         """
         if enable is not None:
             pulumi.set(__self__, "enable", enable)
+        if optional_fields is not None:
+            pulumi.set(__self__, "optional_fields", optional_fields)
+        if optional_mode is not None:
+            pulumi.set(__self__, "optional_mode", optional_mode)
         if sample_rate is not None:
             pulumi.set(__self__, "sample_rate", sample_rate)
 
@@ -5037,6 +5141,34 @@ class BackendServiceLogConfigArgs:
     def enable(self, value: Optional[pulumi.Input[builtins.bool]]):
         pulumi.set(self, "enable", value)
 
+    @property
+    @pulumi.getter(name="optionalFields")
+    def optional_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
+        """
+        This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+        was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+        For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        """
+        return pulumi.get(self, "optional_fields")
+
+    @optional_fields.setter
+    def optional_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
+        pulumi.set(self, "optional_fields", value)
+
+    @property
+    @pulumi.getter(name="optionalMode")
+    def optional_mode(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Specifies the optional logging mode for the load balancer traffic.
+        Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM.
+        Possible values are: `INCLUDE_ALL_OPTIONAL`, `EXCLUDE_ALL_OPTIONAL`, `CUSTOM`.
+        """
+        return pulumi.get(self, "optional_mode")
+
+    @optional_mode.setter
+    def optional_mode(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "optional_mode", value)
+
     @property
     @pulumi.getter(name="sampleRate")
     def sample_rate(self) -> Optional[pulumi.Input[builtins.float]]:
@@ -5053,6 +5185,63 @@ class BackendServiceLogConfigArgs:
         pulumi.set(self, "sample_rate", value)
 
 
+if not MYPY:
+    class BackendServiceMaxStreamDurationArgsDict(TypedDict):
+        seconds: pulumi.Input[builtins.str]
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)
+        """
+        nanos: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Span of time that's a fraction of a second at nanosecond resolution.
+        Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+        Must be from 0 to 999,999,999 inclusive.
+        """
+elif False:
+    BackendServiceMaxStreamDurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class BackendServiceMaxStreamDurationArgs:
+    def __init__(__self__, *,
+                 seconds: pulumi.Input[builtins.str],
+                 nanos: Optional[pulumi.Input[builtins.int]] = None):
+        """
+        :param pulumi.Input[builtins.str] seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)
+        :param pulumi.Input[builtins.int] nanos: Span of time that's a fraction of a second at nanosecond resolution.
+               Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+               Must be from 0 to 999,999,999 inclusive.
+        """
+        pulumi.set(__self__, "seconds", seconds)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> pulumi.Input[builtins.str]:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)
+        """
+        return pulumi.get(self, "seconds")
+
+    @seconds.setter
+    def seconds(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "seconds", value)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        Span of time that's a fraction of a second at nanosecond resolution.
+        Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+        Must be from 0 to 999,999,999 inclusive.
+        """
+        return pulumi.get(self, "nanos")
+
+    @nanos.setter
+    def nanos(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "nanos", value)
+
+
 if not MYPY:
     class BackendServiceOutlierDetectionArgsDict(TypedDict):
         base_ejection_time: NotRequired[pulumi.Input['BackendServiceOutlierDetectionBaseEjectionTimeArgsDict']]
@@ -22473,41 +22662,69 @@ class InstanceTemplateDiskArgs:
 
 if not MYPY:
     class InstanceTemplateDiskDiskEncryptionKeyArgsDict(TypedDict):
-        kms_key_self_link: pulumi.Input[builtins.str]
+        kms_key_self_link: NotRequired[pulumi.Input[builtins.str]]
         """
         The self link of the encryption key that is stored in Google Cloud KMS
         """
+        kms_key_service_account: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The service account being used for the
+        encryption request for the given KMS key. If absent, the Compute Engine
+        default service account is used.
+        """
 elif False:
     InstanceTemplateDiskDiskEncryptionKeyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class InstanceTemplateDiskDiskEncryptionKeyArgs:
     def __init__(__self__, *,
-                 kms_key_self_link: pulumi.Input[builtins.str]):
+                 kms_key_self_link: Optional[pulumi.Input[builtins.str]] = None,
+                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
+        :param pulumi.Input[builtins.str] kms_key_service_account: The service account being used for the
+               encryption request for the given KMS key. If absent, the Compute Engine
+               default service account is used.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_service_account is not None:
+            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> pulumi.Input[builtins.str]:
+    def kms_key_self_link(self) -> Optional[pulumi.Input[builtins.str]]:
         """
         The self link of the encryption key that is stored in Google Cloud KMS
         """
         return pulumi.get(self, "kms_key_self_link")
 
     @kms_key_self_link.setter
-    def kms_key_self_link(self, value: pulumi.Input[builtins.str]):
+    def kms_key_self_link(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_self_link", value)
 
+    @property
+    @pulumi.getter(name="kmsKeyServiceAccount")
+    def kms_key_service_account(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The service account being used for the
+        encryption request for the given KMS key. If absent, the Compute Engine
+        default service account is used.
+        """
+        return pulumi.get(self, "kms_key_service_account")
+
+    @kms_key_service_account.setter
+    def kms_key_service_account(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "kms_key_service_account", value)
+
 
 if not MYPY:
     class InstanceTemplateDiskSourceImageEncryptionKeyArgsDict(TypedDict):
-        kms_key_self_link: pulumi.Input[builtins.str]
+        kms_key_self_link: NotRequired[pulumi.Input[builtins.str]]
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         kms_key_service_account: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -22515,36 +22732,67 @@ if not MYPY:
         encryption request for the given KMS key. If absent, the Compute Engine
         default service account is used.
         """
+        raw_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        rsa_encrypted_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
 elif False:
     InstanceTemplateDiskSourceImageEncryptionKeyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class InstanceTemplateDiskSourceImageEncryptionKeyArgs:
     def __init__(__self__, *,
-                 kms_key_self_link: pulumi.Input[builtins.str],
-                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None):
+                 kms_key_self_link: Optional[pulumi.Input[builtins.str]] = None,
+                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None,
+                 raw_key: Optional[pulumi.Input[builtins.str]] = None,
+                 rsa_encrypted_key: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param pulumi.Input[builtins.str] kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param pulumi.Input[builtins.str] raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param pulumi.Input[builtins.str] rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> pulumi.Input[builtins.str]:
+    def kms_key_self_link(self) -> Optional[pulumi.Input[builtins.str]]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
     @kms_key_self_link.setter
-    def kms_key_self_link(self, value: pulumi.Input[builtins.str]):
+    def kms_key_self_link(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_self_link", value)
 
     @property
@@ -22561,13 +22809,44 @@ class InstanceTemplateDiskSourceImageEncryptionKeyArgs:
     def kms_key_service_account(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_service_account", value)
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @raw_key.setter
+    def raw_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "raw_key", value)
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
+    @rsa_encrypted_key.setter
+    def rsa_encrypted_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "rsa_encrypted_key", value)
+
 
 if not MYPY:
     class InstanceTemplateDiskSourceSnapshotEncryptionKeyArgsDict(TypedDict):
-        kms_key_self_link: pulumi.Input[builtins.str]
+        kms_key_self_link: NotRequired[pulumi.Input[builtins.str]]
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         kms_key_service_account: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -22575,36 +22854,67 @@ if not MYPY:
         encryption request for the given KMS key. If absent, the Compute Engine
         default service account is used.
         """
+        raw_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        rsa_encrypted_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
 elif False:
     InstanceTemplateDiskSourceSnapshotEncryptionKeyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class InstanceTemplateDiskSourceSnapshotEncryptionKeyArgs:
     def __init__(__self__, *,
-                 kms_key_self_link: pulumi.Input[builtins.str],
-                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None):
+                 kms_key_self_link: Optional[pulumi.Input[builtins.str]] = None,
+                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None,
+                 raw_key: Optional[pulumi.Input[builtins.str]] = None,
+                 rsa_encrypted_key: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param pulumi.Input[builtins.str] kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param pulumi.Input[builtins.str] raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param pulumi.Input[builtins.str] rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> pulumi.Input[builtins.str]:
+    def kms_key_self_link(self) -> Optional[pulumi.Input[builtins.str]]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
     @kms_key_self_link.setter
-    def kms_key_self_link(self, value: pulumi.Input[builtins.str]):
+    def kms_key_self_link(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_self_link", value)
 
     @property
@@ -22621,6 +22931,36 @@ class InstanceTemplateDiskSourceSnapshotEncryptionKeyArgs:
     def kms_key_service_account(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_service_account", value)
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @raw_key.setter
+    def raw_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "raw_key", value)
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
+    @rsa_encrypted_key.setter
+    def rsa_encrypted_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "rsa_encrypted_key", value)
+
 
 if not MYPY:
     class InstanceTemplateGuestAcceleratorArgsDict(TypedDict):
@@ -37132,41 +37472,69 @@ class RegionInstanceTemplateDiskArgs:
 
 if not MYPY:
     class RegionInstanceTemplateDiskDiskEncryptionKeyArgsDict(TypedDict):
-        kms_key_self_link: pulumi.Input[builtins.str]
+        kms_key_self_link: NotRequired[pulumi.Input[builtins.str]]
         """
         The self link of the encryption key that is stored in Google Cloud KMS
         """
+        kms_key_service_account: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The service account being used for the
+        encryption request for the given KMS key. If absent, the Compute Engine
+        default service account is used.
+        """
 elif False:
     RegionInstanceTemplateDiskDiskEncryptionKeyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class RegionInstanceTemplateDiskDiskEncryptionKeyArgs:
     def __init__(__self__, *,
-                 kms_key_self_link: pulumi.Input[builtins.str]):
+                 kms_key_self_link: Optional[pulumi.Input[builtins.str]] = None,
+                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
+        :param pulumi.Input[builtins.str] kms_key_service_account: The service account being used for the
+               encryption request for the given KMS key. If absent, the Compute Engine
+               default service account is used.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_service_account is not None:
+            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> pulumi.Input[builtins.str]:
+    def kms_key_self_link(self) -> Optional[pulumi.Input[builtins.str]]:
         """
         The self link of the encryption key that is stored in Google Cloud KMS
         """
         return pulumi.get(self, "kms_key_self_link")
 
     @kms_key_self_link.setter
-    def kms_key_self_link(self, value: pulumi.Input[builtins.str]):
+    def kms_key_self_link(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_self_link", value)
 
+    @property
+    @pulumi.getter(name="kmsKeyServiceAccount")
+    def kms_key_service_account(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The service account being used for the
+        encryption request for the given KMS key. If absent, the Compute Engine
+        default service account is used.
+        """
+        return pulumi.get(self, "kms_key_service_account")
+
+    @kms_key_service_account.setter
+    def kms_key_service_account(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "kms_key_service_account", value)
+
 
 if not MYPY:
     class RegionInstanceTemplateDiskSourceImageEncryptionKeyArgsDict(TypedDict):
-        kms_key_self_link: pulumi.Input[builtins.str]
+        kms_key_self_link: NotRequired[pulumi.Input[builtins.str]]
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         kms_key_service_account: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -37174,36 +37542,67 @@ if not MYPY:
         encryption request for the given KMS key. If absent, the Compute Engine
         default service account is used.
         """
+        raw_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        rsa_encrypted_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
 elif False:
     RegionInstanceTemplateDiskSourceImageEncryptionKeyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class RegionInstanceTemplateDiskSourceImageEncryptionKeyArgs:
     def __init__(__self__, *,
-                 kms_key_self_link: pulumi.Input[builtins.str],
-                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None):
+                 kms_key_self_link: Optional[pulumi.Input[builtins.str]] = None,
+                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None,
+                 raw_key: Optional[pulumi.Input[builtins.str]] = None,
+                 rsa_encrypted_key: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param pulumi.Input[builtins.str] kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param pulumi.Input[builtins.str] raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param pulumi.Input[builtins.str] rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> pulumi.Input[builtins.str]:
+    def kms_key_self_link(self) -> Optional[pulumi.Input[builtins.str]]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
     @kms_key_self_link.setter
-    def kms_key_self_link(self, value: pulumi.Input[builtins.str]):
+    def kms_key_self_link(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_self_link", value)
 
     @property
@@ -37220,13 +37619,44 @@ class RegionInstanceTemplateDiskSourceImageEncryptionKeyArgs:
     def kms_key_service_account(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_service_account", value)
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @raw_key.setter
+    def raw_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "raw_key", value)
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
+    @rsa_encrypted_key.setter
+    def rsa_encrypted_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "rsa_encrypted_key", value)
+
 
 if not MYPY:
     class RegionInstanceTemplateDiskSourceSnapshotEncryptionKeyArgsDict(TypedDict):
-        kms_key_self_link: pulumi.Input[builtins.str]
+        kms_key_self_link: NotRequired[pulumi.Input[builtins.str]]
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         kms_key_service_account: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -37234,36 +37664,67 @@ if not MYPY:
         encryption request for the given KMS key. If absent, the Compute Engine
         default service account is used.
         """
+        raw_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        rsa_encrypted_key: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
 elif False:
     RegionInstanceTemplateDiskSourceSnapshotEncryptionKeyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class RegionInstanceTemplateDiskSourceSnapshotEncryptionKeyArgs:
     def __init__(__self__, *,
-                 kms_key_self_link: pulumi.Input[builtins.str],
-                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None):
+                 kms_key_self_link: Optional[pulumi.Input[builtins.str]] = None,
+                 kms_key_service_account: Optional[pulumi.Input[builtins.str]] = None,
+                 raw_key: Optional[pulumi.Input[builtins.str]] = None,
+                 rsa_encrypted_key: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.str] kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param pulumi.Input[builtins.str] kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param pulumi.Input[builtins.str] raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param pulumi.Input[builtins.str] rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> pulumi.Input[builtins.str]:
+    def kms_key_self_link(self) -> Optional[pulumi.Input[builtins.str]]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
     @kms_key_self_link.setter
-    def kms_key_self_link(self, value: pulumi.Input[builtins.str]):
+    def kms_key_self_link(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_self_link", value)
 
     @property
@@ -37280,6 +37741,36 @@ class RegionInstanceTemplateDiskSourceSnapshotEncryptionKeyArgs:
     def kms_key_service_account(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "kms_key_service_account", value)
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @raw_key.setter
+    def raw_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "raw_key", value)
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
+    @rsa_encrypted_key.setter
+    def rsa_encrypted_key(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "rsa_encrypted_key", value)
+
 
 if not MYPY:
     class RegionInstanceTemplateGuestAcceleratorArgsDict(TypedDict):
@@ -59162,6 +59653,634 @@ class SnapshotSourceDiskEncryptionKeyArgs:
         pulumi.set(self, "rsa_encrypted_key", value)
 
 
+if not MYPY:
+    class StoragePoolIamBindingConditionArgsDict(TypedDict):
+        expression: pulumi.Input[builtins.str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[builtins.str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    StoragePoolIamBindingConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class StoragePoolIamBindingConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[builtins.str],
+                 title: pulumi.Input[builtins.str],
+                 description: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[builtins.str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[builtins.str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[builtins.str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "description", value)
+
+
+if not MYPY:
+    class StoragePoolIamMemberConditionArgsDict(TypedDict):
+        expression: pulumi.Input[builtins.str]
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        title: pulumi.Input[builtins.str]
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        description: NotRequired[pulumi.Input[builtins.str]]
+elif False:
+    StoragePoolIamMemberConditionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class StoragePoolIamMemberConditionArgs:
+    def __init__(__self__, *,
+                 expression: pulumi.Input[builtins.str],
+                 title: pulumi.Input[builtins.str],
+                 description: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] expression: Textual representation of an expression in Common Expression Language syntax.
+        :param pulumi.Input[builtins.str] title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> pulumi.Input[builtins.str]:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @expression.setter
+    def expression(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "expression", value)
+
+    @property
+    @pulumi.getter
+    def title(self) -> pulumi.Input[builtins.str]:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @title.setter
+    def title(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "title", value)
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[pulumi.Input[builtins.str]]:
+        return pulumi.get(self, "description")
+
+    @description.setter
+    def description(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "description", value)
+
+
+if not MYPY:
+    class StoragePoolResourceStatusArgsDict(TypedDict):
+        disk_count: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Number of disks used.
+        """
+        last_resize_timestamp: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Timestamp of the last successful resize in RFC3339 text format.
+        """
+        max_total_provisioned_disk_capacity_gb: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Maximum allowed aggregate disk size in gigabytes.
+        """
+        pool_used_capacity_bytes: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Space used by data stored in disks within the storage pool (in bytes).
+        This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        """
+        pool_used_iops: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        """
+        pool_used_throughput: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s.
+        """
+        pool_user_written_bytes: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Amount of data written into the pool, before it is compacted.
+        """
+        total_provisioned_disk_capacity_gb: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the capacity provisioned in disks in this storage pool.
+        A disk's provisioned capacity is the same as its total capacity.
+        """
+        total_provisioned_disk_iops: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS.
+        """
+        total_provisioned_disk_throughput: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s,
+        minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+elif False:
+    StoragePoolResourceStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class StoragePoolResourceStatusArgs:
+    def __init__(__self__, *,
+                 disk_count: Optional[pulumi.Input[builtins.str]] = None,
+                 last_resize_timestamp: Optional[pulumi.Input[builtins.str]] = None,
+                 max_total_provisioned_disk_capacity_gb: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_used_capacity_bytes: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_used_iops: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_used_throughput: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_user_written_bytes: Optional[pulumi.Input[builtins.str]] = None,
+                 total_provisioned_disk_capacity_gb: Optional[pulumi.Input[builtins.str]] = None,
+                 total_provisioned_disk_iops: Optional[pulumi.Input[builtins.str]] = None,
+                 total_provisioned_disk_throughput: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] disk_count: (Output)
+               Number of disks used.
+        :param pulumi.Input[builtins.str] last_resize_timestamp: (Output)
+               Timestamp of the last successful resize in RFC3339 text format.
+        :param pulumi.Input[builtins.str] max_total_provisioned_disk_capacity_gb: (Output)
+               Maximum allowed aggregate disk size in gigabytes.
+        :param pulumi.Input[builtins.str] pool_used_capacity_bytes: (Output)
+               Space used by data stored in disks within the storage pool (in bytes).
+               This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        :param pulumi.Input[builtins.str] pool_used_iops: (Output)
+               Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        :param pulumi.Input[builtins.str] pool_used_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s.
+        :param pulumi.Input[builtins.str] pool_user_written_bytes: (Output)
+               Amount of data written into the pool, before it is compacted.
+        :param pulumi.Input[builtins.str] total_provisioned_disk_capacity_gb: (Output)
+               Sum of all the capacity provisioned in disks in this storage pool.
+               A disk's provisioned capacity is the same as its total capacity.
+        :param pulumi.Input[builtins.str] total_provisioned_disk_iops: (Output)
+               Sum of all the disks' provisioned IOPS.
+        :param pulumi.Input[builtins.str] total_provisioned_disk_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s,
+               minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        if disk_count is not None:
+            pulumi.set(__self__, "disk_count", disk_count)
+        if last_resize_timestamp is not None:
+            pulumi.set(__self__, "last_resize_timestamp", last_resize_timestamp)
+        if max_total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "max_total_provisioned_disk_capacity_gb", max_total_provisioned_disk_capacity_gb)
+        if pool_used_capacity_bytes is not None:
+            pulumi.set(__self__, "pool_used_capacity_bytes", pool_used_capacity_bytes)
+        if pool_used_iops is not None:
+            pulumi.set(__self__, "pool_used_iops", pool_used_iops)
+        if pool_used_throughput is not None:
+            pulumi.set(__self__, "pool_used_throughput", pool_used_throughput)
+        if pool_user_written_bytes is not None:
+            pulumi.set(__self__, "pool_user_written_bytes", pool_user_written_bytes)
+        if total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "total_provisioned_disk_capacity_gb", total_provisioned_disk_capacity_gb)
+        if total_provisioned_disk_iops is not None:
+            pulumi.set(__self__, "total_provisioned_disk_iops", total_provisioned_disk_iops)
+        if total_provisioned_disk_throughput is not None:
+            pulumi.set(__self__, "total_provisioned_disk_throughput", total_provisioned_disk_throughput)
+
+    @property
+    @pulumi.getter(name="diskCount")
+    def disk_count(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Number of disks used.
+        """
+        return pulumi.get(self, "disk_count")
+
+    @disk_count.setter
+    def disk_count(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "disk_count", value)
+
+    @property
+    @pulumi.getter(name="lastResizeTimestamp")
+    def last_resize_timestamp(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Timestamp of the last successful resize in RFC3339 text format.
+        """
+        return pulumi.get(self, "last_resize_timestamp")
+
+    @last_resize_timestamp.setter
+    def last_resize_timestamp(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "last_resize_timestamp", value)
+
+    @property
+    @pulumi.getter(name="maxTotalProvisionedDiskCapacityGb")
+    def max_total_provisioned_disk_capacity_gb(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Maximum allowed aggregate disk size in gigabytes.
+        """
+        return pulumi.get(self, "max_total_provisioned_disk_capacity_gb")
+
+    @max_total_provisioned_disk_capacity_gb.setter
+    def max_total_provisioned_disk_capacity_gb(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "max_total_provisioned_disk_capacity_gb", value)
+
+    @property
+    @pulumi.getter(name="poolUsedCapacityBytes")
+    def pool_used_capacity_bytes(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Space used by data stored in disks within the storage pool (in bytes).
+        This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        """
+        return pulumi.get(self, "pool_used_capacity_bytes")
+
+    @pool_used_capacity_bytes.setter
+    def pool_used_capacity_bytes(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_used_capacity_bytes", value)
+
+    @property
+    @pulumi.getter(name="poolUsedIops")
+    def pool_used_iops(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        """
+        return pulumi.get(self, "pool_used_iops")
+
+    @pool_used_iops.setter
+    def pool_used_iops(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_used_iops", value)
+
+    @property
+    @pulumi.getter(name="poolUsedThroughput")
+    def pool_used_throughput(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s.
+        """
+        return pulumi.get(self, "pool_used_throughput")
+
+    @pool_used_throughput.setter
+    def pool_used_throughput(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_used_throughput", value)
+
+    @property
+    @pulumi.getter(name="poolUserWrittenBytes")
+    def pool_user_written_bytes(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Amount of data written into the pool, before it is compacted.
+        """
+        return pulumi.get(self, "pool_user_written_bytes")
+
+    @pool_user_written_bytes.setter
+    def pool_user_written_bytes(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_user_written_bytes", value)
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskCapacityGb")
+    def total_provisioned_disk_capacity_gb(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the capacity provisioned in disks in this storage pool.
+        A disk's provisioned capacity is the same as its total capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_capacity_gb")
+
+    @total_provisioned_disk_capacity_gb.setter
+    def total_provisioned_disk_capacity_gb(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "total_provisioned_disk_capacity_gb", value)
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskIops")
+    def total_provisioned_disk_iops(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS.
+        """
+        return pulumi.get(self, "total_provisioned_disk_iops")
+
+    @total_provisioned_disk_iops.setter
+    def total_provisioned_disk_iops(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "total_provisioned_disk_iops", value)
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskThroughput")
+    def total_provisioned_disk_throughput(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s,
+        minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_throughput")
+
+    @total_provisioned_disk_throughput.setter
+    def total_provisioned_disk_throughput(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "total_provisioned_disk_throughput", value)
+
+
+if not MYPY:
+    class StoragePoolStatusArgsDict(TypedDict):
+        disk_count: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Number of disks used.
+        """
+        last_resize_timestamp: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Timestamp of the last successful resize in RFC3339 text format.
+        """
+        max_total_provisioned_disk_capacity_gb: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Maximum allowed aggregate disk size in gigabytes.
+        """
+        pool_used_capacity_bytes: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Space used by data stored in disks within the storage pool (in bytes).
+        This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        """
+        pool_used_iops: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        """
+        pool_used_throughput: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s.
+        """
+        pool_user_written_bytes: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Amount of data written into the pool, before it is compacted.
+        """
+        total_provisioned_disk_capacity_gb: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the capacity provisioned in disks in this storage pool.
+        A disk's provisioned capacity is the same as its total capacity.
+        """
+        total_provisioned_disk_iops: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS.
+        """
+        total_provisioned_disk_throughput: NotRequired[pulumi.Input[builtins.str]]
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s,
+        minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+elif False:
+    StoragePoolStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class StoragePoolStatusArgs:
+    def __init__(__self__, *,
+                 disk_count: Optional[pulumi.Input[builtins.str]] = None,
+                 last_resize_timestamp: Optional[pulumi.Input[builtins.str]] = None,
+                 max_total_provisioned_disk_capacity_gb: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_used_capacity_bytes: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_used_iops: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_used_throughput: Optional[pulumi.Input[builtins.str]] = None,
+                 pool_user_written_bytes: Optional[pulumi.Input[builtins.str]] = None,
+                 total_provisioned_disk_capacity_gb: Optional[pulumi.Input[builtins.str]] = None,
+                 total_provisioned_disk_iops: Optional[pulumi.Input[builtins.str]] = None,
+                 total_provisioned_disk_throughput: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] disk_count: (Output)
+               Number of disks used.
+        :param pulumi.Input[builtins.str] last_resize_timestamp: (Output)
+               Timestamp of the last successful resize in RFC3339 text format.
+        :param pulumi.Input[builtins.str] max_total_provisioned_disk_capacity_gb: (Output)
+               Maximum allowed aggregate disk size in gigabytes.
+        :param pulumi.Input[builtins.str] pool_used_capacity_bytes: (Output)
+               Space used by data stored in disks within the storage pool (in bytes).
+               This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        :param pulumi.Input[builtins.str] pool_used_iops: (Output)
+               Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        :param pulumi.Input[builtins.str] pool_used_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s.
+        :param pulumi.Input[builtins.str] pool_user_written_bytes: (Output)
+               Amount of data written into the pool, before it is compacted.
+        :param pulumi.Input[builtins.str] total_provisioned_disk_capacity_gb: (Output)
+               Sum of all the capacity provisioned in disks in this storage pool.
+               A disk's provisioned capacity is the same as its total capacity.
+        :param pulumi.Input[builtins.str] total_provisioned_disk_iops: (Output)
+               Sum of all the disks' provisioned IOPS.
+        :param pulumi.Input[builtins.str] total_provisioned_disk_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s,
+               minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        if disk_count is not None:
+            pulumi.set(__self__, "disk_count", disk_count)
+        if last_resize_timestamp is not None:
+            pulumi.set(__self__, "last_resize_timestamp", last_resize_timestamp)
+        if max_total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "max_total_provisioned_disk_capacity_gb", max_total_provisioned_disk_capacity_gb)
+        if pool_used_capacity_bytes is not None:
+            pulumi.set(__self__, "pool_used_capacity_bytes", pool_used_capacity_bytes)
+        if pool_used_iops is not None:
+            pulumi.set(__self__, "pool_used_iops", pool_used_iops)
+        if pool_used_throughput is not None:
+            pulumi.set(__self__, "pool_used_throughput", pool_used_throughput)
+        if pool_user_written_bytes is not None:
+            pulumi.set(__self__, "pool_user_written_bytes", pool_user_written_bytes)
+        if total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "total_provisioned_disk_capacity_gb", total_provisioned_disk_capacity_gb)
+        if total_provisioned_disk_iops is not None:
+            pulumi.set(__self__, "total_provisioned_disk_iops", total_provisioned_disk_iops)
+        if total_provisioned_disk_throughput is not None:
+            pulumi.set(__self__, "total_provisioned_disk_throughput", total_provisioned_disk_throughput)
+
+    @property
+    @pulumi.getter(name="diskCount")
+    def disk_count(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Number of disks used.
+        """
+        return pulumi.get(self, "disk_count")
+
+    @disk_count.setter
+    def disk_count(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "disk_count", value)
+
+    @property
+    @pulumi.getter(name="lastResizeTimestamp")
+    def last_resize_timestamp(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Timestamp of the last successful resize in RFC3339 text format.
+        """
+        return pulumi.get(self, "last_resize_timestamp")
+
+    @last_resize_timestamp.setter
+    def last_resize_timestamp(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "last_resize_timestamp", value)
+
+    @property
+    @pulumi.getter(name="maxTotalProvisionedDiskCapacityGb")
+    def max_total_provisioned_disk_capacity_gb(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Maximum allowed aggregate disk size in gigabytes.
+        """
+        return pulumi.get(self, "max_total_provisioned_disk_capacity_gb")
+
+    @max_total_provisioned_disk_capacity_gb.setter
+    def max_total_provisioned_disk_capacity_gb(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "max_total_provisioned_disk_capacity_gb", value)
+
+    @property
+    @pulumi.getter(name="poolUsedCapacityBytes")
+    def pool_used_capacity_bytes(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Space used by data stored in disks within the storage pool (in bytes).
+        This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        """
+        return pulumi.get(self, "pool_used_capacity_bytes")
+
+    @pool_used_capacity_bytes.setter
+    def pool_used_capacity_bytes(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_used_capacity_bytes", value)
+
+    @property
+    @pulumi.getter(name="poolUsedIops")
+    def pool_used_iops(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        """
+        return pulumi.get(self, "pool_used_iops")
+
+    @pool_used_iops.setter
+    def pool_used_iops(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_used_iops", value)
+
+    @property
+    @pulumi.getter(name="poolUsedThroughput")
+    def pool_used_throughput(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s.
+        """
+        return pulumi.get(self, "pool_used_throughput")
+
+    @pool_used_throughput.setter
+    def pool_used_throughput(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_used_throughput", value)
+
+    @property
+    @pulumi.getter(name="poolUserWrittenBytes")
+    def pool_user_written_bytes(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Amount of data written into the pool, before it is compacted.
+        """
+        return pulumi.get(self, "pool_user_written_bytes")
+
+    @pool_user_written_bytes.setter
+    def pool_user_written_bytes(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "pool_user_written_bytes", value)
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskCapacityGb")
+    def total_provisioned_disk_capacity_gb(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the capacity provisioned in disks in this storage pool.
+        A disk's provisioned capacity is the same as its total capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_capacity_gb")
+
+    @total_provisioned_disk_capacity_gb.setter
+    def total_provisioned_disk_capacity_gb(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "total_provisioned_disk_capacity_gb", value)
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskIops")
+    def total_provisioned_disk_iops(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS.
+        """
+        return pulumi.get(self, "total_provisioned_disk_iops")
+
+    @total_provisioned_disk_iops.setter
+    def total_provisioned_disk_iops(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "total_provisioned_disk_iops", value)
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskThroughput")
+    def total_provisioned_disk_throughput(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s,
+        minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_throughput")
+
+    @total_provisioned_disk_throughput.setter
+    def total_provisioned_disk_throughput(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "total_provisioned_disk_throughput", value)
+
+
 if not MYPY:
     class SubnetworkIAMBindingConditionArgsDict(TypedDict):
         expression: pulumi.Input[builtins.str]