pulumi-gcp 7.3.0a1702567892__py3-none-any.whl → 7.3.1__py3-none-any.whl

pulumi_gcp/compute/global_forwarding_rule.py

@@ -30,6 +30,7 @@ class GlobalForwardingRuleArgs:
                  no_automate_dns_zone: Optional[pulumi.Input[bool]] = None,
                  port_range: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 service_directory_registrations: Optional[pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']] = None,
                  source_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  subnetwork: Optional[pulumi.Input[str]] = None):
         """
@@ -157,6 +158,9 @@ class GlobalForwardingRuleArgs:
                cannot have overlapping `portRange`s.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs'] service_directory_registrations: Service Directory resources to register this forwarding rule with.
+               Currently, only supports a single Service Directory resource.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] source_ip_ranges: If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each sourceIpRange entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24).
         :param pulumi.Input[str] subnetwork: This field identifies the subnetwork that the load balanced IP should
                belong to for this Forwarding Rule, used in internal load balancing and
@@ -192,6 +196,8 @@ class GlobalForwardingRuleArgs:
             pulumi.set(__self__, "port_range", port_range)
         if project is not None:
             pulumi.set(__self__, "project", project)
+        if service_directory_registrations is not None:
+            pulumi.set(__self__, "service_directory_registrations", service_directory_registrations)
         if source_ip_ranges is not None:
             pulumi.set(__self__, "source_ip_ranges", source_ip_ranges)
         if subnetwork is not None:
@@ -474,6 +480,20 @@ class GlobalForwardingRuleArgs:
     def project(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "project", value)
 
+    @property
+    @pulumi.getter(name="serviceDirectoryRegistrations")
+    def service_directory_registrations(self) -> Optional[pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']]:
+        """
+        Service Directory resources to register this forwarding rule with.
+        Currently, only supports a single Service Directory resource.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "service_directory_registrations")
+
+    @service_directory_registrations.setter
+    def service_directory_registrations(self, value: Optional[pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']]):
+        pulumi.set(self, "service_directory_registrations", value)
+
     @property
     @pulumi.getter(name="sourceIpRanges")
     def source_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
@@ -527,6 +547,7 @@ class _GlobalForwardingRuleState:
                  psc_connection_status: Optional[pulumi.Input[str]] = None,
                  pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  self_link: Optional[pulumi.Input[str]] = None,
+                 service_directory_registrations: Optional[pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']] = None,
                  source_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  subnetwork: Optional[pulumi.Input[str]] = None,
                  target: Optional[pulumi.Input[str]] = None):
@@ -650,6 +671,9 @@ class _GlobalForwardingRuleState:
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
         :param pulumi.Input[str] self_link: The URI of the created resource.
+        :param pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs'] service_directory_registrations: Service Directory resources to register this forwarding rule with.
+               Currently, only supports a single Service Directory resource.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] source_ip_ranges: If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each sourceIpRange entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24).
         :param pulumi.Input[str] subnetwork: This field identifies the subnetwork that the load balanced IP should
                belong to for this Forwarding Rule, used in internal load balancing and
@@ -712,6 +736,8 @@ class _GlobalForwardingRuleState:
             pulumi.set(__self__, "pulumi_labels", pulumi_labels)
         if self_link is not None:
             pulumi.set(__self__, "self_link", self_link)
+        if service_directory_registrations is not None:
+            pulumi.set(__self__, "service_directory_registrations", service_directory_registrations)
         if source_ip_ranges is not None:
             pulumi.set(__self__, "source_ip_ranges", source_ip_ranges)
         if subnetwork is not None:
@@ -1057,6 +1083,20 @@ class _GlobalForwardingRuleState:
     def self_link(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "self_link", value)
 
+    @property
+    @pulumi.getter(name="serviceDirectoryRegistrations")
+    def service_directory_registrations(self) -> Optional[pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']]:
+        """
+        Service Directory resources to register this forwarding rule with.
+        Currently, only supports a single Service Directory resource.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "service_directory_registrations")
+
+    @service_directory_registrations.setter
+    def service_directory_registrations(self, value: Optional[pulumi.Input['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']]):
+        pulumi.set(self, "service_directory_registrations", value)
+
     @property
     @pulumi.getter(name="sourceIpRanges")
     def source_ip_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
@@ -1130,6 +1170,7 @@ class GlobalForwardingRule(pulumi.CustomResource):
                  no_automate_dns_zone: Optional[pulumi.Input[bool]] = None,
                  port_range: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 service_directory_registrations: Optional[pulumi.Input[pulumi.InputType['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']]] = None,
                  source_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  subnetwork: Optional[pulumi.Input[str]] = None,
                  target: Optional[pulumi.Input[str]] = None,
@@ -1208,6 +1249,10 @@ class GlobalForwardingRule(pulumi.CustomResource):
             network=network.id,
             ip_address=default_global_address.id,
             load_balancing_scheme="",
+            service_directory_registrations=gcp.compute.GlobalForwardingRuleServiceDirectoryRegistrationsArgs(
+                namespace="sd-namespace",
+                service_directory_region="europe-west3",
+            ),
             opts=pulumi.ResourceOptions(provider=google_beta))
         ```
         ### Private Service Connect Google Apis No Automate Dns
@@ -1379,6 +1424,9 @@ class GlobalForwardingRule(pulumi.CustomResource):
                cannot have overlapping `portRange`s.
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
+        :param pulumi.Input[pulumi.InputType['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']] service_directory_registrations: Service Directory resources to register this forwarding rule with.
+               Currently, only supports a single Service Directory resource.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] source_ip_ranges: If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each sourceIpRange entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24).
         :param pulumi.Input[str] subnetwork: This field identifies the subnetwork that the load balanced IP should
                belong to for this Forwarding Rule, used in internal load balancing and
@@ -1481,6 +1529,10 @@ class GlobalForwardingRule(pulumi.CustomResource):
             network=network.id,
             ip_address=default_global_address.id,
             load_balancing_scheme="",
+            service_directory_registrations=gcp.compute.GlobalForwardingRuleServiceDirectoryRegistrationsArgs(
+                namespace="sd-namespace",
+                service_directory_region="europe-west3",
+            ),
             opts=pulumi.ResourceOptions(provider=google_beta))
         ```
         ### Private Service Connect Google Apis No Automate Dns
@@ -1569,6 +1621,7 @@ class GlobalForwardingRule(pulumi.CustomResource):
                  no_automate_dns_zone: Optional[pulumi.Input[bool]] = None,
                  port_range: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
+                 service_directory_registrations: Optional[pulumi.Input[pulumi.InputType['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']]] = None,
                  source_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  subnetwork: Optional[pulumi.Input[str]] = None,
                  target: Optional[pulumi.Input[str]] = None,
@@ -1594,6 +1647,7 @@ class GlobalForwardingRule(pulumi.CustomResource):
             __props__.__dict__["no_automate_dns_zone"] = no_automate_dns_zone
             __props__.__dict__["port_range"] = port_range
             __props__.__dict__["project"] = project
+            __props__.__dict__["service_directory_registrations"] = service_directory_registrations
             __props__.__dict__["source_ip_ranges"] = source_ip_ranges
             __props__.__dict__["subnetwork"] = subnetwork
             if target is None and not opts.urn:
@@ -1638,6 +1692,7 @@ class GlobalForwardingRule(pulumi.CustomResource):
             psc_connection_status: Optional[pulumi.Input[str]] = None,
             pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             self_link: Optional[pulumi.Input[str]] = None,
+            service_directory_registrations: Optional[pulumi.Input[pulumi.InputType['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']]] = None,
             source_ip_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             subnetwork: Optional[pulumi.Input[str]] = None,
             target: Optional[pulumi.Input[str]] = None) -> 'GlobalForwardingRule':
@@ -1766,6 +1821,9 @@ class GlobalForwardingRule(pulumi.CustomResource):
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] pulumi_labels: The combination of labels configured directly on the resource
                and default labels configured on the provider.
         :param pulumi.Input[str] self_link: The URI of the created resource.
+        :param pulumi.Input[pulumi.InputType['GlobalForwardingRuleServiceDirectoryRegistrationsArgs']] service_directory_registrations: Service Directory resources to register this forwarding rule with.
+               Currently, only supports a single Service Directory resource.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] source_ip_ranges: If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each sourceIpRange entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24).
         :param pulumi.Input[str] subnetwork: This field identifies the subnetwork that the load balanced IP should
                belong to for this Forwarding Rule, used in internal load balancing and
@@ -1812,6 +1870,7 @@ class GlobalForwardingRule(pulumi.CustomResource):
         __props__.__dict__["psc_connection_status"] = psc_connection_status
         __props__.__dict__["pulumi_labels"] = pulumi_labels
         __props__.__dict__["self_link"] = self_link
+        __props__.__dict__["service_directory_registrations"] = service_directory_registrations
         __props__.__dict__["source_ip_ranges"] = source_ip_ranges
         __props__.__dict__["subnetwork"] = subnetwork
         __props__.__dict__["target"] = target
@@ -2075,6 +2134,16 @@ class GlobalForwardingRule(pulumi.CustomResource):
         """
         return pulumi.get(self, "self_link")
 
+    @property
+    @pulumi.getter(name="serviceDirectoryRegistrations")
+    def service_directory_registrations(self) -> pulumi.Output['outputs.GlobalForwardingRuleServiceDirectoryRegistrations']:
+        """
+        Service Directory resources to register this forwarding rule with.
+        Currently, only supports a single Service Directory resource.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "service_directory_registrations")
+
     @property
     @pulumi.getter(name="sourceIpRanges")
     def source_ip_ranges(self) -> pulumi.Output[Optional[Sequence[str]]]:

pulumi_gcp/compute/outputs.py

@@ -64,6 +64,7 @@ __all__ = [
     'ForwardingRuleServiceDirectoryRegistrations',
     'GlobalForwardingRuleMetadataFilter',
     'GlobalForwardingRuleMetadataFilterFilterLabel',
+    'GlobalForwardingRuleServiceDirectoryRegistrations',
     'HaVpnGatewayVpnInterface',
     'HealthCheckGrpcHealthCheck',
     'HealthCheckHttp2HealthCheck',
@@ -556,6 +557,7 @@ __all__ = [
     'GetForwardingRuleServiceDirectoryRegistrationResult',
     'GetGlobalForwardingRuleMetadataFilterResult',
     'GetGlobalForwardingRuleMetadataFilterFilterLabelResult',
+    'GetGlobalForwardingRuleServiceDirectoryRegistrationResult',
     'GetHcVpnGatewayVpnInterfaceResult',
     'GetHealthCheckGrpcHealthCheckResult',
     'GetHealthCheckHttp2HealthCheckResult',
@@ -4478,6 +4480,60 @@ class GlobalForwardingRuleMetadataFilterFilterLabel(dict):
         return pulumi.get(self, "value")
 
 
+@pulumi.output_type
+class GlobalForwardingRuleServiceDirectoryRegistrations(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "serviceDirectoryRegion":
+            suggest = "service_directory_region"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in GlobalForwardingRuleServiceDirectoryRegistrations. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        GlobalForwardingRuleServiceDirectoryRegistrations.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        GlobalForwardingRuleServiceDirectoryRegistrations.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 namespace: Optional[str] = None,
+                 service_directory_region: Optional[str] = None):
+        """
+        :param str namespace: Service Directory namespace to register the forwarding rule under.
+        :param str service_directory_region: [Optional] Service Directory region to register this global forwarding rule under.
+               Default to "us-central1". Only used for PSC for Google APIs. All PSC for
+               Google APIs Forwarding Rules on the same network should use the same Service
+               Directory region.
+        """
+        if namespace is not None:
+            pulumi.set(__self__, "namespace", namespace)
+        if service_directory_region is not None:
+            pulumi.set(__self__, "service_directory_region", service_directory_region)
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> Optional[str]:
+        """
+        Service Directory namespace to register the forwarding rule under.
+        """
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter(name="serviceDirectoryRegion")
+    def service_directory_region(self) -> Optional[str]:
+        """
+        [Optional] Service Directory region to register this global forwarding rule under.
+        Default to "us-central1". Only used for PSC for Google APIs. All PSC for
+        Google APIs Forwarding Rules on the same network should use the same Service
+        Directory region.
+        """
+        return pulumi.get(self, "service_directory_region")
+
+
 @pulumi.output_type
 class HaVpnGatewayVpnInterface(dict):
     @staticmethod
@@ -37557,6 +37613,25 @@ class GetGlobalForwardingRuleMetadataFilterFilterLabelResult(dict):
         return pulumi.get(self, "value")
 
 
+@pulumi.output_type
+class GetGlobalForwardingRuleServiceDirectoryRegistrationResult(dict):
+    def __init__(__self__, *,
+                 namespace: str,
+                 service_directory_region: str):
+        pulumi.set(__self__, "namespace", namespace)
+        pulumi.set(__self__, "service_directory_region", service_directory_region)
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> str:
+        return pulumi.get(self, "namespace")
+
+    @property
+    @pulumi.getter(name="serviceDirectoryRegion")
+    def service_directory_region(self) -> str:
+        return pulumi.get(self, "service_directory_region")
+
+
 @pulumi.output_type
 class GetHcVpnGatewayVpnInterfaceResult(dict):
     def __init__(__self__, *,

pulumi_gcp/config/__init__.pyi

@@ -216,10 +216,14 @@ lookerCustomEndpoint: Optional[str]
 
 memcacheCustomEndpoint: Optional[str]
 
+migrationCenterCustomEndpoint: Optional[str]
+
 mlEngineCustomEndpoint: Optional[str]
 
 monitoringCustomEndpoint: Optional[str]
 
+netappCustomEndpoint: Optional[str]
+
 networkConnectivityCustomEndpoint: Optional[str]
 
 networkManagementCustomEndpoint: Optional[str]
@@ -268,6 +272,8 @@ scopes: Optional[str]
 
 secretManagerCustomEndpoint: Optional[str]
 
+secureSourceManagerCustomEndpoint: Optional[str]
+
 securityCenterCustomEndpoint: Optional[str]
 
 securityScannerCustomEndpoint: Optional[str]

pulumi_gcp/config/vars.py

@@ -428,6 +428,10 @@ class _ExportableConfig(types.ModuleType):
     def memcache_custom_endpoint(self) -> Optional[str]:
         return __config__.get('memcacheCustomEndpoint')
 
+    @property
+    def migration_center_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('migrationCenterCustomEndpoint')
+
     @property
     def ml_engine_custom_endpoint(self) -> Optional[str]:
         return __config__.get('mlEngineCustomEndpoint')
@@ -436,6 +440,10 @@ class _ExportableConfig(types.ModuleType):
     def monitoring_custom_endpoint(self) -> Optional[str]:
         return __config__.get('monitoringCustomEndpoint')
 
+    @property
+    def netapp_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('netappCustomEndpoint')
+
     @property
     def network_connectivity_custom_endpoint(self) -> Optional[str]:
         return __config__.get('networkConnectivityCustomEndpoint')
@@ -532,6 +540,10 @@ class _ExportableConfig(types.ModuleType):
     def secret_manager_custom_endpoint(self) -> Optional[str]:
         return __config__.get('secretManagerCustomEndpoint')
 
+    @property
+    def secure_source_manager_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('secureSourceManagerCustomEndpoint')
+
     @property
     def security_center_custom_endpoint(self) -> Optional[str]:
         return __config__.get('securityCenterCustomEndpoint')

pulumi_gcp/container/_inputs.py

@@ -188,6 +188,7 @@ __all__ = [
     'ClusterNodePoolNodeConfigTaintArgs',
     'ClusterNodePoolNodeConfigWorkloadMetadataConfigArgs',
     'ClusterNodePoolPlacementPolicyArgs',
+    'ClusterNodePoolQueuedProvisioningArgs',
     'ClusterNodePoolUpgradeSettingsArgs',
     'ClusterNodePoolUpgradeSettingsBlueGreenSettingsArgs',
     'ClusterNodePoolUpgradeSettingsBlueGreenSettingsStandardRolloutPolicyArgs',
@@ -237,6 +238,7 @@ __all__ = [
     'NodePoolNodeConfigTaintArgs',
     'NodePoolNodeConfigWorkloadMetadataConfigArgs',
     'NodePoolPlacementPolicyArgs',
+    'NodePoolQueuedProvisioningArgs',
     'NodePoolUpgradeSettingsArgs',
     'NodePoolUpgradeSettingsBlueGreenSettingsArgs',
     'NodePoolUpgradeSettingsBlueGreenSettingsStandardRolloutPolicyArgs',
@@ -7104,6 +7106,7 @@ class ClusterNodePoolArgs:
                  node_count: Optional[pulumi.Input[int]] = None,
                  node_locations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  placement_policy: Optional[pulumi.Input['ClusterNodePoolPlacementPolicyArgs']] = None,
+                 queued_provisioning: Optional[pulumi.Input['ClusterNodePoolQueuedProvisioningArgs']] = None,
                  upgrade_settings: Optional[pulumi.Input['ClusterNodePoolUpgradeSettingsArgs']] = None,
                  version: Optional[pulumi.Input[str]] = None):
         """
@@ -7164,6 +7167,8 @@ class ClusterNodePoolArgs:
             pulumi.set(__self__, "node_locations", node_locations)
         if placement_policy is not None:
             pulumi.set(__self__, "placement_policy", placement_policy)
+        if queued_provisioning is not None:
+            pulumi.set(__self__, "queued_provisioning", queued_provisioning)
         if upgrade_settings is not None:
             pulumi.set(__self__, "upgrade_settings", upgrade_settings)
         if version is not None:
@@ -7327,6 +7332,15 @@ class ClusterNodePoolArgs:
     def placement_policy(self, value: Optional[pulumi.Input['ClusterNodePoolPlacementPolicyArgs']]):
         pulumi.set(self, "placement_policy", value)
 
+    @property
+    @pulumi.getter(name="queuedProvisioning")
+    def queued_provisioning(self) -> Optional[pulumi.Input['ClusterNodePoolQueuedProvisioningArgs']]:
+        return pulumi.get(self, "queued_provisioning")
+
+    @queued_provisioning.setter
+    def queued_provisioning(self, value: Optional[pulumi.Input['ClusterNodePoolQueuedProvisioningArgs']]):
+        pulumi.set(self, "queued_provisioning", value)
+
     @property
     @pulumi.getter(name="upgradeSettings")
     def upgrade_settings(self) -> Optional[pulumi.Input['ClusterNodePoolUpgradeSettingsArgs']]:
@@ -9460,6 +9474,28 @@ class ClusterNodePoolPlacementPolicyArgs:
         pulumi.set(self, "tpu_topology", value)
 
 
+@pulumi.input_type
+class ClusterNodePoolQueuedProvisioningArgs:
+    def __init__(__self__, *,
+                 enabled: pulumi.Input[bool]):
+        """
+        :param pulumi.Input[bool] enabled: Enable Binary Authorization for this cluster. Deprecated in favor of `evaluation_mode`.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> pulumi.Input[bool]:
+        """
+        Enable Binary Authorization for this cluster. Deprecated in favor of `evaluation_mode`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "enabled", value)
+
+
 @pulumi.input_type
 class ClusterNodePoolUpgradeSettingsArgs:
     def __init__(__self__, *,
@@ -11793,6 +11829,28 @@ class NodePoolPlacementPolicyArgs:
         pulumi.set(self, "tpu_topology", value)
 
 
+@pulumi.input_type
+class NodePoolQueuedProvisioningArgs:
+    def __init__(__self__, *,
+                 enabled: pulumi.Input[bool]):
+        """
+        :param pulumi.Input[bool] enabled: Makes nodes obtainable through the [ProvisioningRequest API](https://cloud.google.com/kubernetes-engine/docs/how-to/provisioningrequest) exclusively.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> pulumi.Input[bool]:
+        """
+        Makes nodes obtainable through the [ProvisioningRequest API](https://cloud.google.com/kubernetes-engine/docs/how-to/provisioningrequest) exclusively.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: pulumi.Input[bool]):
+        pulumi.set(self, "enabled", value)
+
+
 @pulumi.input_type
 class NodePoolUpgradeSettingsArgs:
     def __init__(__self__, *,