pulumi-gcp 8.21.0a1741156431__py3-none-any.whl → 8.22.0__py3-none-any.whl

pulumi_gcp/compute/subnetwork.py

@@ -26,6 +26,7 @@ class SubnetworkArgs:
                  description: Optional[pulumi.Input[str]] = None,
                  external_ipv6_prefix: Optional[pulumi.Input[str]] = None,
                  ip_cidr_range: Optional[pulumi.Input[str]] = None,
+                 ip_collection: Optional[pulumi.Input[str]] = None,
                  ipv6_access_type: Optional[pulumi.Input[str]] = None,
                  log_config: Optional[pulumi.Input['SubnetworkLogConfigArgs']] = None,
                  name: Optional[pulumi.Input[str]] = None,
@@ -59,6 +60,15 @@ class SubnetworkArgs:
                10.0.0.0/8 or 192.168.0.0/16. Ranges must be unique and
                non-overlapping within a network. Only IPv4 is supported.
                Field is optional when `reserved_internal_range` is defined, otherwise required.
+        :param pulumi.Input[str] ip_collection: Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+               in EXTERNAL_IPV6_SUBNETWORK_CREATION mode.
+               Use one of the following formats to specify a sub-PDP when creating an
+               IPv6 NetLB forwarding rule using BYOIP:
+               Full resource URL, as in:
+               * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               Partial URL, as in:
+               * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
         :param pulumi.Input[str] ipv6_access_type: The access type of IPv6 address this subnet holds. It's immutable and can only be specified during creation
                or the first time the subnet is updated into IPV4_IPV6 dual stack. If the ipv6_type is EXTERNAL then this subnet
                cannot enable direct path.
@@ -121,6 +131,8 @@ class SubnetworkArgs:
             pulumi.set(__self__, "external_ipv6_prefix", external_ipv6_prefix)
         if ip_cidr_range is not None:
             pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+        if ip_collection is not None:
+            pulumi.set(__self__, "ip_collection", ip_collection)
         if ipv6_access_type is not None:
             pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
         if log_config is not None:
@@ -221,6 +233,26 @@ class SubnetworkArgs:
     def ip_cidr_range(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "ip_cidr_range", value)
 
+    @property
+    @pulumi.getter(name="ipCollection")
+    def ip_collection(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+        in EXTERNAL_IPV6_SUBNETWORK_CREATION mode.
+        Use one of the following formats to specify a sub-PDP when creating an
+        IPv6 NetLB forwarding rule using BYOIP:
+        Full resource URL, as in:
+        * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        Partial URL, as in:
+        * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        """
+        return pulumi.get(self, "ip_collection")
+
+    @ip_collection.setter
+    def ip_collection(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ip_collection", value)
+
     @property
     @pulumi.getter(name="ipv6AccessType")
     def ipv6_access_type(self) -> Optional[pulumi.Input[str]]:
@@ -428,8 +460,10 @@ class _SubnetworkState:
                  gateway_address: Optional[pulumi.Input[str]] = None,
                  internal_ipv6_prefix: Optional[pulumi.Input[str]] = None,
                  ip_cidr_range: Optional[pulumi.Input[str]] = None,
+                 ip_collection: Optional[pulumi.Input[str]] = None,
                  ipv6_access_type: Optional[pulumi.Input[str]] = None,
                  ipv6_cidr_range: Optional[pulumi.Input[str]] = None,
+                 ipv6_gce_endpoint: Optional[pulumi.Input[str]] = None,
                  log_config: Optional[pulumi.Input['SubnetworkLogConfigArgs']] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network: Optional[pulumi.Input[str]] = None,
@@ -465,11 +499,25 @@ class _SubnetworkState:
                10.0.0.0/8 or 192.168.0.0/16. Ranges must be unique and
                non-overlapping within a network. Only IPv4 is supported.
                Field is optional when `reserved_internal_range` is defined, otherwise required.
+        :param pulumi.Input[str] ip_collection: Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+               in EXTERNAL_IPV6_SUBNETWORK_CREATION mode.
+               Use one of the following formats to specify a sub-PDP when creating an
+               IPv6 NetLB forwarding rule using BYOIP:
+               Full resource URL, as in:
+               * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               Partial URL, as in:
+               * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
         :param pulumi.Input[str] ipv6_access_type: The access type of IPv6 address this subnet holds. It's immutable and can only be specified during creation
                or the first time the subnet is updated into IPV4_IPV6 dual stack. If the ipv6_type is EXTERNAL then this subnet
                cannot enable direct path.
                Possible values are: `EXTERNAL`, `INTERNAL`.
         :param pulumi.Input[str] ipv6_cidr_range: The range of internal IPv6 addresses that are owned by this subnetwork.
+        :param pulumi.Input[str] ipv6_gce_endpoint: Possible endpoints of this subnetwork. It can be one of the following:
+               * VM_ONLY: The subnetwork can be used for creating instances and IPv6 addresses with VM endpoint type. Such a subnetwork
+               gets external IPv6 ranges from a public delegated prefix and cannot be used to create NetLb.
+               * VM_AND_FR: The subnetwork can be used for creating both VM instances and Forwarding Rules. It can also be used to reserve
+               IPv6 addresses with both VM and FR endpoint types. Such a subnetwork gets its IPv6 range from Google IP Pool directly.
         :param pulumi.Input['SubnetworkLogConfigArgs'] log_config: This field denotes the VPC flow logging options for this subnetwork. If
                logging is enabled, logs are exported to Cloud Logging. Flow logging
                isn't supported if the subnet `purpose` field is set to subnetwork is
@@ -545,10 +593,14 @@ class _SubnetworkState:
             pulumi.set(__self__, "internal_ipv6_prefix", internal_ipv6_prefix)
         if ip_cidr_range is not None:
             pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
+        if ip_collection is not None:
+            pulumi.set(__self__, "ip_collection", ip_collection)
         if ipv6_access_type is not None:
             pulumi.set(__self__, "ipv6_access_type", ipv6_access_type)
         if ipv6_cidr_range is not None:
             pulumi.set(__self__, "ipv6_cidr_range", ipv6_cidr_range)
+        if ipv6_gce_endpoint is not None:
+            pulumi.set(__self__, "ipv6_gce_endpoint", ipv6_gce_endpoint)
         if log_config is not None:
             pulumi.set(__self__, "log_config", log_config)
         if name is not None:
@@ -687,6 +739,26 @@ class _SubnetworkState:
     def ip_cidr_range(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "ip_cidr_range", value)
 
+    @property
+    @pulumi.getter(name="ipCollection")
+    def ip_collection(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+        in EXTERNAL_IPV6_SUBNETWORK_CREATION mode.
+        Use one of the following formats to specify a sub-PDP when creating an
+        IPv6 NetLB forwarding rule using BYOIP:
+        Full resource URL, as in:
+        * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        Partial URL, as in:
+        * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        """
+        return pulumi.get(self, "ip_collection")
+
+    @ip_collection.setter
+    def ip_collection(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ip_collection", value)
+
     @property
     @pulumi.getter(name="ipv6AccessType")
     def ipv6_access_type(self) -> Optional[pulumi.Input[str]]:
@@ -714,6 +786,22 @@ class _SubnetworkState:
     def ipv6_cidr_range(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "ipv6_cidr_range", value)
 
+    @property
+    @pulumi.getter(name="ipv6GceEndpoint")
+    def ipv6_gce_endpoint(self) -> Optional[pulumi.Input[str]]:
+        """
+        Possible endpoints of this subnetwork. It can be one of the following:
+        * VM_ONLY: The subnetwork can be used for creating instances and IPv6 addresses with VM endpoint type. Such a subnetwork
+        gets external IPv6 ranges from a public delegated prefix and cannot be used to create NetLb.
+        * VM_AND_FR: The subnetwork can be used for creating both VM instances and Forwarding Rules. It can also be used to reserve
+        IPv6 addresses with both VM and FR endpoint types. Such a subnetwork gets its IPv6 range from Google IP Pool directly.
+        """
+        return pulumi.get(self, "ipv6_gce_endpoint")
+
+    @ipv6_gce_endpoint.setter
+    def ipv6_gce_endpoint(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ipv6_gce_endpoint", value)
+
     @property
     @pulumi.getter(name="logConfig")
     def log_config(self) -> Optional[pulumi.Input['SubnetworkLogConfigArgs']]:
@@ -944,6 +1032,7 @@ class Subnetwork(pulumi.CustomResource):
                  description: Optional[pulumi.Input[str]] = None,
                  external_ipv6_prefix: Optional[pulumi.Input[str]] = None,
                  ip_cidr_range: Optional[pulumi.Input[str]] = None,
+                 ip_collection: Optional[pulumi.Input[str]] = None,
                  ipv6_access_type: Optional[pulumi.Input[str]] = None,
                  log_config: Optional[pulumi.Input[Union['SubnetworkLogConfigArgs', 'SubnetworkLogConfigArgsDict']]] = None,
                  name: Optional[pulumi.Input[str]] = None,
@@ -1216,6 +1305,15 @@ class Subnetwork(pulumi.CustomResource):
                10.0.0.0/8 or 192.168.0.0/16. Ranges must be unique and
                non-overlapping within a network. Only IPv4 is supported.
                Field is optional when `reserved_internal_range` is defined, otherwise required.
+        :param pulumi.Input[str] ip_collection: Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+               in EXTERNAL_IPV6_SUBNETWORK_CREATION mode.
+               Use one of the following formats to specify a sub-PDP when creating an
+               IPv6 NetLB forwarding rule using BYOIP:
+               Full resource URL, as in:
+               * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               Partial URL, as in:
+               * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
         :param pulumi.Input[str] ipv6_access_type: The access type of IPv6 address this subnet holds. It's immutable and can only be specified during creation
                or the first time the subnet is updated into IPV4_IPV6 dual stack. If the ipv6_type is EXTERNAL then this subnet
                cannot enable direct path.
@@ -1541,6 +1639,7 @@ class Subnetwork(pulumi.CustomResource):
                  description: Optional[pulumi.Input[str]] = None,
                  external_ipv6_prefix: Optional[pulumi.Input[str]] = None,
                  ip_cidr_range: Optional[pulumi.Input[str]] = None,
+                 ip_collection: Optional[pulumi.Input[str]] = None,
                  ipv6_access_type: Optional[pulumi.Input[str]] = None,
                  log_config: Optional[pulumi.Input[Union['SubnetworkLogConfigArgs', 'SubnetworkLogConfigArgsDict']]] = None,
                  name: Optional[pulumi.Input[str]] = None,
@@ -1568,6 +1667,7 @@ class Subnetwork(pulumi.CustomResource):
             __props__.__dict__["description"] = description
             __props__.__dict__["external_ipv6_prefix"] = external_ipv6_prefix
             __props__.__dict__["ip_cidr_range"] = ip_cidr_range
+            __props__.__dict__["ip_collection"] = ip_collection
             __props__.__dict__["ipv6_access_type"] = ipv6_access_type
             __props__.__dict__["log_config"] = log_config
             __props__.__dict__["name"] = name
@@ -1589,6 +1689,7 @@ class Subnetwork(pulumi.CustomResource):
             __props__.__dict__["gateway_address"] = None
             __props__.__dict__["internal_ipv6_prefix"] = None
             __props__.__dict__["ipv6_cidr_range"] = None
+            __props__.__dict__["ipv6_gce_endpoint"] = None
             __props__.__dict__["self_link"] = None
             __props__.__dict__["subnetwork_id"] = None
         super(Subnetwork, __self__).__init__(
@@ -1609,8 +1710,10 @@ class Subnetwork(pulumi.CustomResource):
             gateway_address: Optional[pulumi.Input[str]] = None,
             internal_ipv6_prefix: Optional[pulumi.Input[str]] = None,
             ip_cidr_range: Optional[pulumi.Input[str]] = None,
+            ip_collection: Optional[pulumi.Input[str]] = None,
             ipv6_access_type: Optional[pulumi.Input[str]] = None,
             ipv6_cidr_range: Optional[pulumi.Input[str]] = None,
+            ipv6_gce_endpoint: Optional[pulumi.Input[str]] = None,
             log_config: Optional[pulumi.Input[Union['SubnetworkLogConfigArgs', 'SubnetworkLogConfigArgsDict']]] = None,
             name: Optional[pulumi.Input[str]] = None,
             network: Optional[pulumi.Input[str]] = None,
@@ -1651,11 +1754,25 @@ class Subnetwork(pulumi.CustomResource):
                10.0.0.0/8 or 192.168.0.0/16. Ranges must be unique and
                non-overlapping within a network. Only IPv4 is supported.
                Field is optional when `reserved_internal_range` is defined, otherwise required.
+        :param pulumi.Input[str] ip_collection: Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+               in EXTERNAL_IPV6_SUBNETWORK_CREATION mode.
+               Use one of the following formats to specify a sub-PDP when creating an
+               IPv6 NetLB forwarding rule using BYOIP:
+               Full resource URL, as in:
+               * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               Partial URL, as in:
+               * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+               * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
         :param pulumi.Input[str] ipv6_access_type: The access type of IPv6 address this subnet holds. It's immutable and can only be specified during creation
                or the first time the subnet is updated into IPV4_IPV6 dual stack. If the ipv6_type is EXTERNAL then this subnet
                cannot enable direct path.
                Possible values are: `EXTERNAL`, `INTERNAL`.
         :param pulumi.Input[str] ipv6_cidr_range: The range of internal IPv6 addresses that are owned by this subnetwork.
+        :param pulumi.Input[str] ipv6_gce_endpoint: Possible endpoints of this subnetwork. It can be one of the following:
+               * VM_ONLY: The subnetwork can be used for creating instances and IPv6 addresses with VM endpoint type. Such a subnetwork
+               gets external IPv6 ranges from a public delegated prefix and cannot be used to create NetLb.
+               * VM_AND_FR: The subnetwork can be used for creating both VM instances and Forwarding Rules. It can also be used to reserve
+               IPv6 addresses with both VM and FR endpoint types. Such a subnetwork gets its IPv6 range from Google IP Pool directly.
         :param pulumi.Input[Union['SubnetworkLogConfigArgs', 'SubnetworkLogConfigArgsDict']] log_config: This field denotes the VPC flow logging options for this subnetwork. If
                logging is enabled, logs are exported to Cloud Logging. Flow logging
                isn't supported if the subnet `purpose` field is set to subnetwork is
@@ -1724,8 +1841,10 @@ class Subnetwork(pulumi.CustomResource):
         __props__.__dict__["gateway_address"] = gateway_address
         __props__.__dict__["internal_ipv6_prefix"] = internal_ipv6_prefix
         __props__.__dict__["ip_cidr_range"] = ip_cidr_range
+        __props__.__dict__["ip_collection"] = ip_collection
         __props__.__dict__["ipv6_access_type"] = ipv6_access_type
         __props__.__dict__["ipv6_cidr_range"] = ipv6_cidr_range
+        __props__.__dict__["ipv6_gce_endpoint"] = ipv6_gce_endpoint
         __props__.__dict__["log_config"] = log_config
         __props__.__dict__["name"] = name
         __props__.__dict__["network"] = network
@@ -1818,6 +1937,22 @@ class Subnetwork(pulumi.CustomResource):
         """
         return pulumi.get(self, "ip_cidr_range")
 
+    @property
+    @pulumi.getter(name="ipCollection")
+    def ip_collection(self) -> pulumi.Output[Optional[str]]:
+        """
+        Resource reference of a PublicDelegatedPrefix. The PDP must be a sub-PDP
+        in EXTERNAL_IPV6_SUBNETWORK_CREATION mode.
+        Use one of the following formats to specify a sub-PDP when creating an
+        IPv6 NetLB forwarding rule using BYOIP:
+        Full resource URL, as in:
+        * `https://www.googleapis.com/compute/v1/projects/{{projectId}}/regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        Partial URL, as in:
+        * `projects/{{projectId}}/regions/region/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        * `regions/{{region}}/publicDelegatedPrefixes/{{sub-pdp-name}}`
+        """
+        return pulumi.get(self, "ip_collection")
+
     @property
     @pulumi.getter(name="ipv6AccessType")
     def ipv6_access_type(self) -> pulumi.Output[Optional[str]]:
@@ -1837,6 +1972,18 @@ class Subnetwork(pulumi.CustomResource):
         """
         return pulumi.get(self, "ipv6_cidr_range")
 
+    @property
+    @pulumi.getter(name="ipv6GceEndpoint")
+    def ipv6_gce_endpoint(self) -> pulumi.Output[str]:
+        """
+        Possible endpoints of this subnetwork. It can be one of the following:
+        * VM_ONLY: The subnetwork can be used for creating instances and IPv6 addresses with VM endpoint type. Such a subnetwork
+        gets external IPv6 ranges from a public delegated prefix and cannot be used to create NetLb.
+        * VM_AND_FR: The subnetwork can be used for creating both VM instances and Forwarding Rules. It can also be used to reserve
+        IPv6 addresses with both VM and FR endpoint types. Such a subnetwork gets its IPv6 range from Google IP Pool directly.
+        """
+        return pulumi.get(self, "ipv6_gce_endpoint")
+
     @property
     @pulumi.getter(name="logConfig")
     def log_config(self) -> pulumi.Output[Optional['outputs.SubnetworkLogConfig']]:

pulumi_gcp/compute/url_map.py

@@ -979,6 +979,10 @@ class URLMap(pulumi.CustomResource):
                                 }],
                             },
                         }],
+                        "max_stream_duration": {
+                            "nanos": 500000,
+                            "seconds": "9",
+                        },
                     },
                 }],
             }],
@@ -1719,6 +1723,10 @@ class URLMap(pulumi.CustomResource):
                                 }],
                             },
                         }],
+                        "max_stream_duration": {
+                            "nanos": 500000,
+                            "seconds": "9",
+                        },
                     },
                 }],
             }],

pulumi_gcp/container/_inputs.py

@@ -8164,7 +8164,7 @@ if not MYPY:
         """
         enable_components: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
         """
-        The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR` and `DCGM`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above.
+        The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR`, `DCGM` and `JOBSET`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above. `JOBSET` is only supported in GKE 1.32.1-gke.1357001 and above.
         """
         managed_prometheus: NotRequired[pulumi.Input['ClusterMonitoringConfigManagedPrometheusArgsDict']]
         """
@@ -8181,7 +8181,7 @@ class ClusterMonitoringConfigArgs:
                  managed_prometheus: Optional[pulumi.Input['ClusterMonitoringConfigManagedPrometheusArgs']] = None):
         """
         :param pulumi.Input['ClusterMonitoringConfigAdvancedDatapathObservabilityConfigArgs'] advanced_datapath_observability_config: Configuration for Advanced Datapath Monitoring. Structure is documented below.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] enable_components: The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR` and `DCGM`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] enable_components: The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR`, `DCGM` and `JOBSET`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above. `JOBSET` is only supported in GKE 1.32.1-gke.1357001 and above.
         :param pulumi.Input['ClusterMonitoringConfigManagedPrometheusArgs'] managed_prometheus: Configuration for Managed Service for Prometheus. Structure is documented below.
         """
         if advanced_datapath_observability_config is not None:
@@ -8207,7 +8207,7 @@ class ClusterMonitoringConfigArgs:
     @pulumi.getter(name="enableComponents")
     def enable_components(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
-        The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR` and `DCGM`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above.
+        The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR`, `DCGM` and `JOBSET`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above. `JOBSET` is only supported in GKE 1.32.1-gke.1357001 and above.
         """
         return pulumi.get(self, "enable_components")
 
@@ -15699,7 +15699,7 @@ if not MYPY:
     class ClusterNotificationConfigPubsubFilterArgsDict(TypedDict):
         event_types: pulumi.Input[Sequence[pulumi.Input[str]]]
         """
-        Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT` and `SECURITY_BULLETIN_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
+        Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT`, `SECURITY_BULLETIN_EVENT` and `UPGRADE_INFO_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
         """
 elif False:
     ClusterNotificationConfigPubsubFilterArgsDict: TypeAlias = Mapping[str, Any]
@@ -15709,7 +15709,7 @@ class ClusterNotificationConfigPubsubFilterArgs:
     def __init__(__self__, *,
                  event_types: pulumi.Input[Sequence[pulumi.Input[str]]]):
         """
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] event_types: Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT` and `SECURITY_BULLETIN_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] event_types: Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT`, `SECURITY_BULLETIN_EVENT` and `UPGRADE_INFO_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
         """
         pulumi.set(__self__, "event_types", event_types)
 
@@ -15717,7 +15717,7 @@ class ClusterNotificationConfigPubsubFilterArgs:
     @pulumi.getter(name="eventTypes")
     def event_types(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
         """
-        Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT` and `SECURITY_BULLETIN_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
+        Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT`, `SECURITY_BULLETIN_EVENT` and `UPGRADE_INFO_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
         """
         return pulumi.get(self, "event_types")
 

pulumi_gcp/container/outputs.py

@@ -6746,7 +6746,7 @@ class ClusterMonitoringConfig(dict):
                  managed_prometheus: Optional['outputs.ClusterMonitoringConfigManagedPrometheus'] = None):
         """
         :param 'ClusterMonitoringConfigAdvancedDatapathObservabilityConfigArgs' advanced_datapath_observability_config: Configuration for Advanced Datapath Monitoring. Structure is documented below.
-        :param Sequence[str] enable_components: The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR` and `DCGM`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above.
+        :param Sequence[str] enable_components: The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR`, `DCGM` and `JOBSET`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above. `JOBSET` is only supported in GKE 1.32.1-gke.1357001 and above.
         :param 'ClusterMonitoringConfigManagedPrometheusArgs' managed_prometheus: Configuration for Managed Service for Prometheus. Structure is documented below.
         """
         if advanced_datapath_observability_config is not None:
@@ -6768,7 +6768,7 @@ class ClusterMonitoringConfig(dict):
     @pulumi.getter(name="enableComponents")
     def enable_components(self) -> Optional[Sequence[str]]:
         """
-        The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR` and `DCGM`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above.
+        The GKE components exposing metrics. Supported values include: `SYSTEM_COMPONENTS`, `APISERVER`, `SCHEDULER`, `CONTROLLER_MANAGER`, `STORAGE`, `HPA`, `POD`, `DAEMONSET`, `DEPLOYMENT`, `STATEFULSET`, `KUBELET`, `CADVISOR`, `DCGM` and `JOBSET`. In beta provider, `WORKLOADS` is supported on top of those 12 values. (`WORKLOADS` is deprecated and removed in GKE 1.24.) `KUBELET` and `CADVISOR` are only supported in GKE 1.29.3-gke.1093000 and above. `JOBSET` is only supported in GKE 1.32.1-gke.1357001 and above.
         """
         return pulumi.get(self, "enable_components")
 
@@ -12643,7 +12643,7 @@ class ClusterNotificationConfigPubsubFilter(dict):
     def __init__(__self__, *,
                  event_types: Sequence[str]):
         """
-        :param Sequence[str] event_types: Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT` and `SECURITY_BULLETIN_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
+        :param Sequence[str] event_types: Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT`, `SECURITY_BULLETIN_EVENT` and `UPGRADE_INFO_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
         """
         pulumi.set(__self__, "event_types", event_types)
 
@@ -12651,7 +12651,7 @@ class ClusterNotificationConfigPubsubFilter(dict):
     @pulumi.getter(name="eventTypes")
     def event_types(self) -> Sequence[str]:
         """
-        Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT` and `SECURITY_BULLETIN_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
+        Can be used to filter what notifications are sent. Accepted values are `UPGRADE_AVAILABLE_EVENT`, `UPGRADE_EVENT`, `SECURITY_BULLETIN_EVENT` and `UPGRADE_INFO_EVENT`. See [Filtering notifications](https://cloud.google.com/kubernetes-engine/docs/concepts/cluster-notifications#filtering) for more details.
         """
         return pulumi.get(self, "event_types")
 
@@ -17790,7 +17790,7 @@ class GetClusterMonitoringConfigResult(dict):
                  managed_prometheuses: Sequence['outputs.GetClusterMonitoringConfigManagedPrometheusResult']):
         """
         :param Sequence['GetClusterMonitoringConfigAdvancedDatapathObservabilityConfigArgs'] advanced_datapath_observability_configs: Configuration of Advanced Datapath Observability features.
-        :param Sequence[str] enable_components: GKE components exposing metrics. Valid values include SYSTEM_COMPONENTS, APISERVER, SCHEDULER, CONTROLLER_MANAGER, STORAGE, HPA, POD, DAEMONSET, DEPLOYMENT, STATEFULSET, WORKLOADS, KUBELET, CADVISOR and DCGM.
+        :param Sequence[str] enable_components: GKE components exposing metrics. Valid values include SYSTEM_COMPONENTS, APISERVER, SCHEDULER, CONTROLLER_MANAGER, STORAGE, HPA, POD, DAEMONSET, DEPLOYMENT, STATEFULSET, WORKLOADS, KUBELET, CADVISOR, DCGM and JOBSET.
         :param Sequence['GetClusterMonitoringConfigManagedPrometheusArgs'] managed_prometheuses: Configuration for Google Cloud Managed Services for Prometheus.
         """
         pulumi.set(__self__, "advanced_datapath_observability_configs", advanced_datapath_observability_configs)
@@ -17809,7 +17809,7 @@ class GetClusterMonitoringConfigResult(dict):
     @pulumi.getter(name="enableComponents")
     def enable_components(self) -> Sequence[str]:
         """
-        GKE components exposing metrics. Valid values include SYSTEM_COMPONENTS, APISERVER, SCHEDULER, CONTROLLER_MANAGER, STORAGE, HPA, POD, DAEMONSET, DEPLOYMENT, STATEFULSET, WORKLOADS, KUBELET, CADVISOR and DCGM.
+        GKE components exposing metrics. Valid values include SYSTEM_COMPONENTS, APISERVER, SCHEDULER, CONTROLLER_MANAGER, STORAGE, HPA, POD, DAEMONSET, DEPLOYMENT, STATEFULSET, WORKLOADS, KUBELET, CADVISOR, DCGM and JOBSET.
         """
         return pulumi.get(self, "enable_components")
 
@@ -21590,7 +21590,7 @@ class GetClusterNotificationConfigPubsubFilterResult(dict):
     def __init__(__self__, *,
                  event_types: Sequence[str]):
         """
-        :param Sequence[str] event_types: Can be used to filter what notifications are sent. Valid values include include UPGRADE_AVAILABLE_EVENT, UPGRADE_EVENT and SECURITY_BULLETIN_EVENT
+        :param Sequence[str] event_types: Can be used to filter what notifications are sent. Valid values include include UPGRADE_AVAILABLE_EVENT, UPGRADE_EVENT, SECURITY_BULLETIN_EVENT, and UPGRADE_INFO_EVENT
         """
         pulumi.set(__self__, "event_types", event_types)
 
@@ -21598,7 +21598,7 @@ class GetClusterNotificationConfigPubsubFilterResult(dict):
     @pulumi.getter(name="eventTypes")
     def event_types(self) -> Sequence[str]:
         """
-        Can be used to filter what notifications are sent. Valid values include include UPGRADE_AVAILABLE_EVENT, UPGRADE_EVENT and SECURITY_BULLETIN_EVENT
+        Can be used to filter what notifications are sent. Valid values include include UPGRADE_AVAILABLE_EVENT, UPGRADE_EVENT, SECURITY_BULLETIN_EVENT, and UPGRADE_INFO_EVENT
         """
         return pulumi.get(self, "event_types")
 

pulumi_gcp/datacatalog/entry.py

@@ -527,6 +527,8 @@ class Entry(pulumi.CustomResource):
                  user_specified_type: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
+        > **Warning:** `datacatalog.Entry` is deprecated and will be removed in a future major release. Data Catalog is deprecated and will be discontinued on January 30, 2026. For steps to transition your Data Catalog users, workloads, and content to Dataplex Catalog, see https://cloud.google.com/dataplex/docs/transition-to-dataplex-catalog.
+
         Entry Metadata. A Data Catalog Entry resource represents another resource in Google Cloud Platform
         (such as a BigQuery dataset or a Pub/Sub topic) or outside of Google Cloud Platform. Clients can use
         the linkedResource field in the Entry resource to refer to the original resource ID of the source system.
@@ -677,6 +679,8 @@ class Entry(pulumi.CustomResource):
                  args: EntryArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
+        > **Warning:** `datacatalog.Entry` is deprecated and will be removed in a future major release. Data Catalog is deprecated and will be discontinued on January 30, 2026. For steps to transition your Data Catalog users, workloads, and content to Dataplex Catalog, see https://cloud.google.com/dataplex/docs/transition-to-dataplex-catalog.
+
         Entry Metadata. A Data Catalog Entry resource represents another resource in Google Cloud Platform
         (such as a BigQuery dataset or a Pub/Sub topic) or outside of Google Cloud Platform. Clients can use
         the linkedResource field in the Entry resource to refer to the original resource ID of the source system.

pulumi_gcp/datacatalog/tag.py

@@ -237,6 +237,8 @@ class Tag(pulumi.CustomResource):
                  template: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
+        > **Warning:** `datacatalog.Tag` is deprecated and will be removed in a future major release. For steps to transition your Data Catalog users, workloads, and content to Dataplex Catalog, see https://cloud.google.com/dataplex/docs/transition-to-dataplex-catalog.
+
         Tags are used to attach custom metadata to Data Catalog resources. Tags conform to the specifications within their tag template.
 
         See [Data Catalog IAM](https://cloud.google.com/data-catalog/docs/concepts/iam) for information on the permissions needed to create or view tags.
@@ -533,6 +535,8 @@ class Tag(pulumi.CustomResource):
                  args: TagArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
+        > **Warning:** `datacatalog.Tag` is deprecated and will be removed in a future major release. For steps to transition your Data Catalog users, workloads, and content to Dataplex Catalog, see https://cloud.google.com/dataplex/docs/transition-to-dataplex-catalog.
+
         Tags are used to attach custom metadata to Data Catalog resources. Tags conform to the specifications within their tag template.
 
         See [Data Catalog IAM](https://cloud.google.com/data-catalog/docs/concepts/iam) for information on the permissions needed to create or view tags.

pulumi_gcp/dataproc/_inputs.py

@@ -4816,7 +4816,7 @@ if not MYPY:
         """
         provisioning_model_mix: NotRequired[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgsDict']]
         """
-        Defines how Dataproc should create VMs with a mixture of provisioning models.
+        Defines how the Group selects the provisioning model to ensure required reliability.
         """
 elif False:
     ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgsDict: TypeAlias = Mapping[str, Any]
@@ -4830,7 +4830,7 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgs:
         """
         :param pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgs']]] instance_selection_lists: List of instance selection options that the group will use when creating new VMs.
         :param pulumi.Input[Sequence[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionResultArgs']]] instance_selection_results: A list of instance selection results in the group.
-        :param pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgs'] provisioning_model_mix: Defines how Dataproc should create VMs with a mixture of provisioning models.
+        :param pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgs'] provisioning_model_mix: Defines how the Group selects the provisioning model to ensure required reliability.
         """
         if instance_selection_lists is not None:
             pulumi.set(__self__, "instance_selection_lists", instance_selection_lists)
@@ -4867,7 +4867,7 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyArgs:
     @pulumi.getter(name="provisioningModelMix")
     def provisioning_model_mix(self) -> Optional[pulumi.Input['ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgs']]:
         """
-        Defines how Dataproc should create VMs with a mixture of provisioning models.
+        Defines how the Group selects the provisioning model to ensure required reliability.
         """
         return pulumi.get(self, "provisioning_model_mix")
 
@@ -4885,8 +4885,6 @@ if not MYPY:
         rank: NotRequired[pulumi.Input[int]]
         """
         Preference of this instance selection. A lower number means higher preference. Dataproc will first try to create a VM based on the machine-type with priority rank and fallback to next rank based on availability. Machine types and instance selections with the same priority have the same preference.
-
-        - - -
         """
 elif False:
     ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstanceSelectionListArgsDict: TypeAlias = Mapping[str, Any]
@@ -4899,8 +4897,6 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstan
         """
         :param pulumi.Input[Sequence[pulumi.Input[str]]] machine_types: Full machine-type names, e.g. `"n1-standard-16"`.
         :param pulumi.Input[int] rank: Preference of this instance selection. A lower number means higher preference. Dataproc will first try to create a VM based on the machine-type with priority rank and fallback to next rank based on availability. Machine types and instance selections with the same priority have the same preference.
-               
-               - - -
         """
         if machine_types is not None:
             pulumi.set(__self__, "machine_types", machine_types)
@@ -4924,8 +4920,6 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyInstan
     def rank(self) -> Optional[pulumi.Input[int]]:
         """
         Preference of this instance selection. A lower number means higher preference. Dataproc will first try to create a VM based on the machine-type with priority rank and fallback to next rank based on availability. Machine types and instance selections with the same priority have the same preference.
-
-        - - -
         """
         return pulumi.get(self, "rank")
 
@@ -4990,11 +4984,12 @@ if not MYPY:
     class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgsDict(TypedDict):
         standard_capacity_base: NotRequired[pulumi.Input[int]]
         """
-        The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need.
+        The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need. Dataproc will create only standard VMs until it reaches standardCapacityBase, then it will start using standardCapacityPercentAboveBase to mix Spot with Standard VMs. eg. If 15 instances are requested and standardCapacityBase is 5, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances.
         """
         standard_capacity_percent_above_base: NotRequired[pulumi.Input[int]]
         """
-        The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs.
+        The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs. The percentage applies only to the capacity above standardCapacityBase. eg. If 15 instances are requested and standardCapacityBase is 5 and standardCapacityPercentAboveBase is 30, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances. The mix will be 30% standard and 70% spot.
+        - - -
         """
 elif False:
     ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvisioningModelMixArgsDict: TypeAlias = Mapping[str, Any]
@@ -5005,8 +5000,9 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvis
                  standard_capacity_base: Optional[pulumi.Input[int]] = None,
                  standard_capacity_percent_above_base: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input[int] standard_capacity_base: The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need.
-        :param pulumi.Input[int] standard_capacity_percent_above_base: The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs.
+        :param pulumi.Input[int] standard_capacity_base: The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need. Dataproc will create only standard VMs until it reaches standardCapacityBase, then it will start using standardCapacityPercentAboveBase to mix Spot with Standard VMs. eg. If 15 instances are requested and standardCapacityBase is 5, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances.
+        :param pulumi.Input[int] standard_capacity_percent_above_base: The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs. The percentage applies only to the capacity above standardCapacityBase. eg. If 15 instances are requested and standardCapacityBase is 5 and standardCapacityPercentAboveBase is 30, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances. The mix will be 30% standard and 70% spot.
+               - - -
         """
         if standard_capacity_base is not None:
             pulumi.set(__self__, "standard_capacity_base", standard_capacity_base)
@@ -5017,7 +5013,7 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvis
     @pulumi.getter(name="standardCapacityBase")
     def standard_capacity_base(self) -> Optional[pulumi.Input[int]]:
         """
-        The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need.
+        The base capacity that will always use Standard VMs to avoid risk of more preemption than the minimum capacity you need. Dataproc will create only standard VMs until it reaches standardCapacityBase, then it will start using standardCapacityPercentAboveBase to mix Spot with Standard VMs. eg. If 15 instances are requested and standardCapacityBase is 5, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances.
         """
         return pulumi.get(self, "standard_capacity_base")
 
@@ -5029,7 +5025,8 @@ class ClusterClusterConfigPreemptibleWorkerConfigInstanceFlexibilityPolicyProvis
     @pulumi.getter(name="standardCapacityPercentAboveBase")
     def standard_capacity_percent_above_base(self) -> Optional[pulumi.Input[int]]:
         """
-        The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs.
+        The percentage of target capacity that should use Standard VM. The remaining percentage will use Spot VMs. The percentage applies only to the capacity above standardCapacityBase. eg. If 15 instances are requested and standardCapacityBase is 5 and standardCapacityPercentAboveBase is 30, Dataproc will create 5 standard VMs and then start mixing spot and standard VMs for remaining 10 instances. The mix will be 30% standard and 70% spot.
+        - - -
         """
         return pulumi.get(self, "standard_capacity_percent_above_base")