pulumi-gcp 8.23.0a1742538920__py3-none-any.whl → 8.24.0__py3-none-any.whl

pulumi_gcp/compute/target_https_proxy.py

@@ -98,7 +98,7 @@ class TargetHttpsProxyArgs:
                Early Data allows a TLS resumption handshake to include the initial application payload
                (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
                This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
+               Possible values are: `STRICT`, `PERMISSIVE`, `UNRESTRICTED`, `DISABLED`.
         """
         pulumi.set(__self__, "url_map", url_map)
         if certificate_manager_certificates is not None:
@@ -326,7 +326,7 @@ class TargetHttpsProxyArgs:
         Early Data allows a TLS resumption handshake to include the initial application payload
         (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
         This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
+        Possible values are: `STRICT`, `PERMISSIVE`, `UNRESTRICTED`, `DISABLED`.
         """
         return pulumi.get(self, "tls_early_data")
 
@@ -418,7 +418,7 @@ class _TargetHttpsProxyState:
                Early Data allows a TLS resumption handshake to include the initial application payload
                (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
                This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
+               Possible values are: `STRICT`, `PERMISSIVE`, `UNRESTRICTED`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -678,7 +678,7 @@ class _TargetHttpsProxyState:
         Early Data allows a TLS resumption handshake to include the initial application payload
         (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
         This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
+        Possible values are: `STRICT`, `PERMISSIVE`, `UNRESTRICTED`, `DISABLED`.
         """
         return pulumi.get(self, "tls_early_data")
 
@@ -1018,7 +1018,7 @@ class TargetHttpsProxy(pulumi.CustomResource):
                Early Data allows a TLS resumption handshake to include the initial application payload
                (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
                This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
+               Possible values are: `STRICT`, `PERMISSIVE`, `UNRESTRICTED`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -1416,7 +1416,7 @@ class TargetHttpsProxy(pulumi.CustomResource):
                Early Data allows a TLS resumption handshake to include the initial application payload
                (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
                This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
+               Possible values are: `STRICT`, `PERMISSIVE`, `UNRESTRICTED`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -1609,7 +1609,7 @@ class TargetHttpsProxy(pulumi.CustomResource):
         Early Data allows a TLS resumption handshake to include the initial application payload
         (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
         This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
+        Possible values are: `STRICT`, `PERMISSIVE`, `UNRESTRICTED`, `DISABLED`.
         """
         return pulumi.get(self, "tls_early_data")
 

pulumi_gcp/config/__init__.pyi

@@ -189,6 +189,8 @@ filestoreCustomEndpoint: Optional[str]
 
 firebaseAppCheckCustomEndpoint: Optional[str]
 
+firebaseAppHostingCustomEndpoint: Optional[str]
+
 firebaseCustomEndpoint: Optional[str]
 
 firebaseDataConnectCustomEndpoint: Optional[str]
@@ -251,6 +253,8 @@ loggingCustomEndpoint: Optional[str]
 
 lookerCustomEndpoint: Optional[str]
 
+lustreCustomEndpoint: Optional[str]
+
 managedKafkaCustomEndpoint: Optional[str]
 
 memcacheCustomEndpoint: Optional[str]
@@ -281,6 +285,8 @@ orgPolicyCustomEndpoint: Optional[str]
 
 osConfigCustomEndpoint: Optional[str]
 
+osConfigV2CustomEndpoint: Optional[str]
+
 osLoginCustomEndpoint: Optional[str]
 
 parallelstoreCustomEndpoint: Optional[str]
@@ -357,6 +363,8 @@ spannerCustomEndpoint: Optional[str]
 
 sqlCustomEndpoint: Optional[str]
 
+storageControlCustomEndpoint: Optional[str]
+
 storageCustomEndpoint: Optional[str]
 
 storageInsightsCustomEndpoint: Optional[str]

pulumi_gcp/config/vars.py

@@ -369,6 +369,10 @@ class _ExportableConfig(types.ModuleType):
     def firebase_app_check_custom_endpoint(self) -> Optional[str]:
         return __config__.get('firebaseAppCheckCustomEndpoint')
 
+    @property
+    def firebase_app_hosting_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('firebaseAppHostingCustomEndpoint')
+
     @property
     def firebase_custom_endpoint(self) -> Optional[str]:
         return __config__.get('firebaseCustomEndpoint')
@@ -493,6 +497,10 @@ class _ExportableConfig(types.ModuleType):
     def looker_custom_endpoint(self) -> Optional[str]:
         return __config__.get('lookerCustomEndpoint')
 
+    @property
+    def lustre_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('lustreCustomEndpoint')
+
     @property
     def managed_kafka_custom_endpoint(self) -> Optional[str]:
         return __config__.get('managedKafkaCustomEndpoint')
@@ -553,6 +561,10 @@ class _ExportableConfig(types.ModuleType):
     def os_config_custom_endpoint(self) -> Optional[str]:
         return __config__.get('osConfigCustomEndpoint')
 
+    @property
+    def os_config_v2_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('osConfigV2CustomEndpoint')
+
     @property
     def os_login_custom_endpoint(self) -> Optional[str]:
         return __config__.get('osLoginCustomEndpoint')
@@ -705,6 +717,10 @@ class _ExportableConfig(types.ModuleType):
     def sql_custom_endpoint(self) -> Optional[str]:
         return __config__.get('sqlCustomEndpoint')
 
+    @property
+    def storage_control_custom_endpoint(self) -> Optional[str]:
+        return __config__.get('storageControlCustomEndpoint')
+
     @property
     def storage_custom_endpoint(self) -> Optional[str]:
         return __config__.get('storageCustomEndpoint')

pulumi_gcp/container/_inputs.py

@@ -219,6 +219,8 @@ __all__ = [
     'ClusterControlPlaneEndpointsConfigArgsDict',
     'ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgs',
     'ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgsDict',
+    'ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgs',
+    'ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgsDict',
     'ClusterCostManagementConfigArgs',
     'ClusterCostManagementConfigArgsDict',
     'ClusterDatabaseEncryptionArgs',
@@ -331,6 +333,8 @@ __all__ = [
     'ClusterNodeConfigSoleTenantConfigNodeAffinityArgsDict',
     'ClusterNodeConfigTaintArgs',
     'ClusterNodeConfigTaintArgsDict',
+    'ClusterNodeConfigWindowsNodeConfigArgs',
+    'ClusterNodeConfigWindowsNodeConfigArgsDict',
     'ClusterNodeConfigWorkloadMetadataConfigArgs',
     'ClusterNodeConfigWorkloadMetadataConfigArgsDict',
     'ClusterNodePoolArgs',
@@ -427,6 +431,8 @@ __all__ = [
     'ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinityArgsDict',
     'ClusterNodePoolNodeConfigTaintArgs',
     'ClusterNodePoolNodeConfigTaintArgsDict',
+    'ClusterNodePoolNodeConfigWindowsNodeConfigArgs',
+    'ClusterNodePoolNodeConfigWindowsNodeConfigArgsDict',
     'ClusterNodePoolNodeConfigWorkloadMetadataConfigArgs',
     'ClusterNodePoolNodeConfigWorkloadMetadataConfigArgsDict',
     'ClusterNodePoolPlacementPolicyArgs',
@@ -445,6 +451,8 @@ __all__ = [
     'ClusterNotificationConfigPubsubArgsDict',
     'ClusterNotificationConfigPubsubFilterArgs',
     'ClusterNotificationConfigPubsubFilterArgsDict',
+    'ClusterPodAutoscalingArgs',
+    'ClusterPodAutoscalingArgsDict',
     'ClusterPodSecurityPolicyConfigArgs',
     'ClusterPodSecurityPolicyConfigArgsDict',
     'ClusterPrivateClusterConfigArgs',
@@ -547,6 +555,8 @@ __all__ = [
     'NodePoolNodeConfigSoleTenantConfigNodeAffinityArgsDict',
     'NodePoolNodeConfigTaintArgs',
     'NodePoolNodeConfigTaintArgsDict',
+    'NodePoolNodeConfigWindowsNodeConfigArgs',
+    'NodePoolNodeConfigWindowsNodeConfigArgsDict',
     'NodePoolNodeConfigWorkloadMetadataConfigArgs',
     'NodePoolNodeConfigWorkloadMetadataConfigArgsDict',
     'NodePoolPlacementPolicyArgs',
@@ -6548,18 +6558,26 @@ if not MYPY:
         """
         DNS endpoint configuration.
         """
+        ip_endpoints_config: NotRequired[pulumi.Input['ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgsDict']]
+        """
+        IP endpoint configuration.
+        """
 elif False:
     ClusterControlPlaneEndpointsConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ClusterControlPlaneEndpointsConfigArgs:
     def __init__(__self__, *,
-                 dns_endpoint_config: Optional[pulumi.Input['ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgs']] = None):
+                 dns_endpoint_config: Optional[pulumi.Input['ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgs']] = None,
+                 ip_endpoints_config: Optional[pulumi.Input['ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgs']] = None):
         """
         :param pulumi.Input['ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgs'] dns_endpoint_config: DNS endpoint configuration.
+        :param pulumi.Input['ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgs'] ip_endpoints_config: IP endpoint configuration.
         """
         if dns_endpoint_config is not None:
             pulumi.set(__self__, "dns_endpoint_config", dns_endpoint_config)
+        if ip_endpoints_config is not None:
+            pulumi.set(__self__, "ip_endpoints_config", ip_endpoints_config)
 
     @property
     @pulumi.getter(name="dnsEndpointConfig")
@@ -6573,6 +6591,18 @@ class ClusterControlPlaneEndpointsConfigArgs:
     def dns_endpoint_config(self, value: Optional[pulumi.Input['ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgs']]):
         pulumi.set(self, "dns_endpoint_config", value)
 
+    @property
+    @pulumi.getter(name="ipEndpointsConfig")
+    def ip_endpoints_config(self) -> Optional[pulumi.Input['ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgs']]:
+        """
+        IP endpoint configuration.
+        """
+        return pulumi.get(self, "ip_endpoints_config")
+
+    @ip_endpoints_config.setter
+    def ip_endpoints_config(self, value: Optional[pulumi.Input['ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgs']]):
+        pulumi.set(self, "ip_endpoints_config", value)
+
 
 if not MYPY:
     class ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgsDict(TypedDict):
@@ -6626,6 +6656,38 @@ class ClusterControlPlaneEndpointsConfigDnsEndpointConfigArgs:
         pulumi.set(self, "endpoint", value)
 
 
+if not MYPY:
+    class ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Controls whether to allow direct IP access. Defaults to `true`.
+        """
+elif False:
+    ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterControlPlaneEndpointsConfigIpEndpointsConfigArgs:
+    def __init__(__self__, *,
+                 enabled: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] enabled: Controls whether to allow direct IP access. Defaults to `true`.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Controls whether to allow direct IP access. Defaults to `true`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enabled", value)
+
+
 if not MYPY:
     class ClusterCostManagementConfigArgsDict(TypedDict):
         enabled: pulumi.Input[bool]
@@ -6767,7 +6829,7 @@ if not MYPY:
         """
         cluster_dns_scope: NotRequired[pulumi.Input[str]]
         """
-        The scope of access to cluster DNS records. `DNS_SCOPE_UNSPECIFIED` (default) or `CLUSTER_SCOPE` or `VPC_SCOPE`.
+        The scope of access to cluster DNS records. `DNS_SCOPE_UNSPECIFIED` or `CLUSTER_SCOPE` or `VPC_SCOPE`. If the `cluster_dns` field is set to `CLOUD_DNS`, `DNS_SCOPE_UNSPECIFIED` and empty/null behave like `CLUSTER_SCOPE`.
         """
 elif False:
     ClusterDnsConfigArgsDict: TypeAlias = Mapping[str, Any]
@@ -6783,7 +6845,7 @@ class ClusterDnsConfigArgs:
         :param pulumi.Input[str] additive_vpc_scope_dns_domain: This will enable Cloud DNS additive VPC scope. Must provide a domain name that is unique within the VPC. For this to work `cluster_dns = "CLOUD_DNS"` and `cluster_dns_scope = "CLUSTER_SCOPE"` must both be set as well.
         :param pulumi.Input[str] cluster_dns: Which in-cluster DNS provider should be used. `PROVIDER_UNSPECIFIED` (default) or `PLATFORM_DEFAULT` or `CLOUD_DNS`.
         :param pulumi.Input[str] cluster_dns_domain: The suffix used for all cluster service records.
-        :param pulumi.Input[str] cluster_dns_scope: The scope of access to cluster DNS records. `DNS_SCOPE_UNSPECIFIED` (default) or `CLUSTER_SCOPE` or `VPC_SCOPE`.
+        :param pulumi.Input[str] cluster_dns_scope: The scope of access to cluster DNS records. `DNS_SCOPE_UNSPECIFIED` or `CLUSTER_SCOPE` or `VPC_SCOPE`. If the `cluster_dns` field is set to `CLOUD_DNS`, `DNS_SCOPE_UNSPECIFIED` and empty/null behave like `CLUSTER_SCOPE`.
         """
         if additive_vpc_scope_dns_domain is not None:
             pulumi.set(__self__, "additive_vpc_scope_dns_domain", additive_vpc_scope_dns_domain)
@@ -6834,7 +6896,7 @@ class ClusterDnsConfigArgs:
     @pulumi.getter(name="clusterDnsScope")
     def cluster_dns_scope(self) -> Optional[pulumi.Input[str]]:
         """
-        The scope of access to cluster DNS records. `DNS_SCOPE_UNSPECIFIED` (default) or `CLUSTER_SCOPE` or `VPC_SCOPE`.
+        The scope of access to cluster DNS records. `DNS_SCOPE_UNSPECIFIED` or `CLUSTER_SCOPE` or `VPC_SCOPE`. If the `cluster_dns` field is set to `CLOUD_DNS`, `DNS_SCOPE_UNSPECIFIED` and empty/null behave like `CLUSTER_SCOPE`.
         """
         return pulumi.get(self, "cluster_dns_scope")
 
@@ -8641,6 +8703,10 @@ if not MYPY:
         this field to manage taints. If you do, `lifecycle.ignore_changes` is
         recommended. Structure is documented below.
         """
+        windows_node_config: NotRequired[pulumi.Input['ClusterNodeConfigWindowsNodeConfigArgsDict']]
+        """
+        Windows node configuration, currently supporting OSVersion [attribute](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/NodeConfig#osversion). The value must be one of [OS_VERSION_UNSPECIFIED, OS_VERSION_LTSC2019, OS_VERSION_LTSC2019]. For example:
+        """
         workload_metadata_config: NotRequired[pulumi.Input['ClusterNodeConfigWorkloadMetadataConfigArgsDict']]
         """
         Metadata configuration to expose to workloads on the node pool.
@@ -8694,6 +8760,7 @@ class ClusterNodeConfigArgs:
                  storage_pools: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  taints: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterNodeConfigTaintArgs']]]] = None,
+                 windows_node_config: Optional[pulumi.Input['ClusterNodeConfigWindowsNodeConfigArgs']] = None,
                  workload_metadata_config: Optional[pulumi.Input['ClusterNodeConfigWorkloadMetadataConfigArgs']] = None):
         """
         :param pulumi.Input['ClusterNodeConfigAdvancedMachineFeaturesArgs'] advanced_machine_features: Specifies options for controlling
@@ -8798,6 +8865,7 @@ class ClusterNodeConfigArgs:
                Kubernetes (eg. through `kubectl`), and it's recommended that you do not use
                this field to manage taints. If you do, `lifecycle.ignore_changes` is
                recommended. Structure is documented below.
+        :param pulumi.Input['ClusterNodeConfigWindowsNodeConfigArgs'] windows_node_config: Windows node configuration, currently supporting OSVersion [attribute](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/NodeConfig#osversion). The value must be one of [OS_VERSION_UNSPECIFIED, OS_VERSION_LTSC2019, OS_VERSION_LTSC2019]. For example:
         :param pulumi.Input['ClusterNodeConfigWorkloadMetadataConfigArgs'] workload_metadata_config: Metadata configuration to expose to workloads on the node pool.
                Structure is documented below.
         """
@@ -8885,6 +8953,8 @@ class ClusterNodeConfigArgs:
             pulumi.set(__self__, "tags", tags)
         if taints is not None:
             pulumi.set(__self__, "taints", taints)
+        if windows_node_config is not None:
+            pulumi.set(__self__, "windows_node_config", windows_node_config)
         if workload_metadata_config is not None:
             pulumi.set(__self__, "workload_metadata_config", workload_metadata_config)
 
@@ -9452,6 +9522,18 @@ class ClusterNodeConfigArgs:
     def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterNodeConfigTaintArgs']]]]):
         pulumi.set(self, "taints", value)
 
+    @property
+    @pulumi.getter(name="windowsNodeConfig")
+    def windows_node_config(self) -> Optional[pulumi.Input['ClusterNodeConfigWindowsNodeConfigArgs']]:
+        """
+        Windows node configuration, currently supporting OSVersion [attribute](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/NodeConfig#osversion). The value must be one of [OS_VERSION_UNSPECIFIED, OS_VERSION_LTSC2019, OS_VERSION_LTSC2019]. For example:
+        """
+        return pulumi.get(self, "windows_node_config")
+
+    @windows_node_config.setter
+    def windows_node_config(self, value: Optional[pulumi.Input['ClusterNodeConfigWindowsNodeConfigArgs']]):
+        pulumi.set(self, "windows_node_config", value)
+
     @property
     @pulumi.getter(name="workloadMetadataConfig")
     def workload_metadata_config(self) -> Optional[pulumi.Input['ClusterNodeConfigWorkloadMetadataConfigArgs']]:
@@ -11068,6 +11150,38 @@ class ClusterNodeConfigTaintArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class ClusterNodeConfigWindowsNodeConfigArgsDict(TypedDict):
+        osversion: NotRequired[pulumi.Input[str]]
+        """
+        The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+elif False:
+    ClusterNodeConfigWindowsNodeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterNodeConfigWindowsNodeConfigArgs:
+    def __init__(__self__, *,
+                 osversion: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] osversion: The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+        if osversion is not None:
+            pulumi.set(__self__, "osversion", osversion)
+
+    @property
+    @pulumi.getter
+    def osversion(self) -> Optional[pulumi.Input[str]]:
+        """
+        The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+        return pulumi.get(self, "osversion")
+
+    @osversion.setter
+    def osversion(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "osversion", value)
+
+
 if not MYPY:
     class ClusterNodeConfigWorkloadMetadataConfigArgsDict(TypedDict):
         mode: pulumi.Input[str]
@@ -12803,6 +12917,10 @@ if not MYPY:
         this field to manage taints. If you do, `lifecycle.ignore_changes` is
         recommended. Structure is documented below.
         """
+        windows_node_config: NotRequired[pulumi.Input['ClusterNodePoolNodeConfigWindowsNodeConfigArgsDict']]
+        """
+        Windows node configuration, currently supporting OSVersion [attribute](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/NodeConfig#osversion). The value must be one of [OS_VERSION_UNSPECIFIED, OS_VERSION_LTSC2019, OS_VERSION_LTSC2019]. For example:
+        """
         workload_metadata_config: NotRequired[pulumi.Input['ClusterNodePoolNodeConfigWorkloadMetadataConfigArgsDict']]
         """
         Metadata configuration to expose to workloads on the node pool.
@@ -12856,6 +12974,7 @@ class ClusterNodePoolNodeConfigArgs:
                  storage_pools: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  taints: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterNodePoolNodeConfigTaintArgs']]]] = None,
+                 windows_node_config: Optional[pulumi.Input['ClusterNodePoolNodeConfigWindowsNodeConfigArgs']] = None,
                  workload_metadata_config: Optional[pulumi.Input['ClusterNodePoolNodeConfigWorkloadMetadataConfigArgs']] = None):
         """
         :param pulumi.Input['ClusterNodePoolNodeConfigAdvancedMachineFeaturesArgs'] advanced_machine_features: Specifies options for controlling
@@ -12960,6 +13079,7 @@ class ClusterNodePoolNodeConfigArgs:
                Kubernetes (eg. through `kubectl`), and it's recommended that you do not use
                this field to manage taints. If you do, `lifecycle.ignore_changes` is
                recommended. Structure is documented below.
+        :param pulumi.Input['ClusterNodePoolNodeConfigWindowsNodeConfigArgs'] windows_node_config: Windows node configuration, currently supporting OSVersion [attribute](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/NodeConfig#osversion). The value must be one of [OS_VERSION_UNSPECIFIED, OS_VERSION_LTSC2019, OS_VERSION_LTSC2019]. For example:
         :param pulumi.Input['ClusterNodePoolNodeConfigWorkloadMetadataConfigArgs'] workload_metadata_config: Metadata configuration to expose to workloads on the node pool.
                Structure is documented below.
         """
@@ -13047,6 +13167,8 @@ class ClusterNodePoolNodeConfigArgs:
             pulumi.set(__self__, "tags", tags)
         if taints is not None:
             pulumi.set(__self__, "taints", taints)
+        if windows_node_config is not None:
+            pulumi.set(__self__, "windows_node_config", windows_node_config)
         if workload_metadata_config is not None:
             pulumi.set(__self__, "workload_metadata_config", workload_metadata_config)
 
@@ -13614,6 +13736,18 @@ class ClusterNodePoolNodeConfigArgs:
     def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterNodePoolNodeConfigTaintArgs']]]]):
         pulumi.set(self, "taints", value)
 
+    @property
+    @pulumi.getter(name="windowsNodeConfig")
+    def windows_node_config(self) -> Optional[pulumi.Input['ClusterNodePoolNodeConfigWindowsNodeConfigArgs']]:
+        """
+        Windows node configuration, currently supporting OSVersion [attribute](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/NodeConfig#osversion). The value must be one of [OS_VERSION_UNSPECIFIED, OS_VERSION_LTSC2019, OS_VERSION_LTSC2019]. For example:
+        """
+        return pulumi.get(self, "windows_node_config")
+
+    @windows_node_config.setter
+    def windows_node_config(self, value: Optional[pulumi.Input['ClusterNodePoolNodeConfigWindowsNodeConfigArgs']]):
+        pulumi.set(self, "windows_node_config", value)
+
     @property
     @pulumi.getter(name="workloadMetadataConfig")
     def workload_metadata_config(self) -> Optional[pulumi.Input['ClusterNodePoolNodeConfigWorkloadMetadataConfigArgs']]:
@@ -15230,6 +15364,38 @@ class ClusterNodePoolNodeConfigTaintArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class ClusterNodePoolNodeConfigWindowsNodeConfigArgsDict(TypedDict):
+        osversion: NotRequired[pulumi.Input[str]]
+        """
+        The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+elif False:
+    ClusterNodePoolNodeConfigWindowsNodeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterNodePoolNodeConfigWindowsNodeConfigArgs:
+    def __init__(__self__, *,
+                 osversion: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] osversion: The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+        if osversion is not None:
+            pulumi.set(__self__, "osversion", osversion)
+
+    @property
+    @pulumi.getter
+    def osversion(self) -> Optional[pulumi.Input[str]]:
+        """
+        The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+        return pulumi.get(self, "osversion")
+
+    @osversion.setter
+    def osversion(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "osversion", value)
+
+
 if not MYPY:
     class ClusterNodePoolNodeConfigWorkloadMetadataConfigArgsDict(TypedDict):
         mode: pulumi.Input[str]
@@ -15726,6 +15892,49 @@ class ClusterNotificationConfigPubsubFilterArgs:
         pulumi.set(self, "event_types", value)
 
 
+if not MYPY:
+    class ClusterPodAutoscalingArgsDict(TypedDict):
+        hpa_profile: pulumi.Input[str]
+        """
+        Enable the Horizontal Pod Autoscaling profile for this cluster.
+        Acceptable values are:
+        * `"NONE"`: Customers explicitly opt-out of HPA profiles.
+        * `"PERFORMANCE"`: PERFORMANCE is used when customers opt-in to the performance HPA profile. In this profile we support a higher number of HPAs per cluster and faster metrics collection for workload autoscaling.
+        See [HPAProfile](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#hpaprofile) for more details.
+        """
+elif False:
+    ClusterPodAutoscalingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterPodAutoscalingArgs:
+    def __init__(__self__, *,
+                 hpa_profile: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] hpa_profile: Enable the Horizontal Pod Autoscaling profile for this cluster.
+               Acceptable values are:
+               * `"NONE"`: Customers explicitly opt-out of HPA profiles.
+               * `"PERFORMANCE"`: PERFORMANCE is used when customers opt-in to the performance HPA profile. In this profile we support a higher number of HPAs per cluster and faster metrics collection for workload autoscaling.
+               See [HPAProfile](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#hpaprofile) for more details.
+        """
+        pulumi.set(__self__, "hpa_profile", hpa_profile)
+
+    @property
+    @pulumi.getter(name="hpaProfile")
+    def hpa_profile(self) -> pulumi.Input[str]:
+        """
+        Enable the Horizontal Pod Autoscaling profile for this cluster.
+        Acceptable values are:
+        * `"NONE"`: Customers explicitly opt-out of HPA profiles.
+        * `"PERFORMANCE"`: PERFORMANCE is used when customers opt-in to the performance HPA profile. In this profile we support a higher number of HPAs per cluster and faster metrics collection for workload autoscaling.
+        See [HPAProfile](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1beta1/projects.locations.clusters#hpaprofile) for more details.
+        """
+        return pulumi.get(self, "hpa_profile")
+
+    @hpa_profile.setter
+    def hpa_profile(self, value: pulumi.Input[str]):
+        pulumi.set(self, "hpa_profile", value)
+
+
 if not MYPY:
     class ClusterPodSecurityPolicyConfigArgsDict(TypedDict):
         enabled: pulumi.Input[bool]
@@ -17457,6 +17666,10 @@ if not MYPY:
         """
         List of Kubernetes taints to be applied to each node.
         """
+        windows_node_config: NotRequired[pulumi.Input['NodePoolNodeConfigWindowsNodeConfigArgsDict']]
+        """
+        Parameters that can be configured on Windows nodes.
+        """
         workload_metadata_config: NotRequired[pulumi.Input['NodePoolNodeConfigWorkloadMetadataConfigArgsDict']]
         """
         The workload metadata configuration for this node.
@@ -17509,6 +17722,7 @@ class NodePoolNodeConfigArgs:
                  storage_pools: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  taints: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigTaintArgs']]]] = None,
+                 windows_node_config: Optional[pulumi.Input['NodePoolNodeConfigWindowsNodeConfigArgs']] = None,
                  workload_metadata_config: Optional[pulumi.Input['NodePoolNodeConfigWorkloadMetadataConfigArgs']] = None):
         """
         :param pulumi.Input['NodePoolNodeConfigAdvancedMachineFeaturesArgs'] advanced_machine_features: Specifies options for controlling advanced machine features.
@@ -17556,6 +17770,7 @@ class NodePoolNodeConfigArgs:
         :param pulumi.Input[Sequence[pulumi.Input[str]]] storage_pools: The list of Storage Pools where boot disks are provisioned.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The list of instance tags applied to all nodes.
         :param pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigTaintArgs']]] taints: List of Kubernetes taints to be applied to each node.
+        :param pulumi.Input['NodePoolNodeConfigWindowsNodeConfigArgs'] windows_node_config: Parameters that can be configured on Windows nodes.
         :param pulumi.Input['NodePoolNodeConfigWorkloadMetadataConfigArgs'] workload_metadata_config: The workload metadata configuration for this node.
         """
         if advanced_machine_features is not None:
@@ -17642,6 +17857,8 @@ class NodePoolNodeConfigArgs:
             pulumi.set(__self__, "tags", tags)
         if taints is not None:
             pulumi.set(__self__, "taints", taints)
+        if windows_node_config is not None:
+            pulumi.set(__self__, "windows_node_config", windows_node_config)
         if workload_metadata_config is not None:
             pulumi.set(__self__, "workload_metadata_config", workload_metadata_config)
 
@@ -18152,6 +18369,18 @@ class NodePoolNodeConfigArgs:
     def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigTaintArgs']]]]):
         pulumi.set(self, "taints", value)
 
+    @property
+    @pulumi.getter(name="windowsNodeConfig")
+    def windows_node_config(self) -> Optional[pulumi.Input['NodePoolNodeConfigWindowsNodeConfigArgs']]:
+        """
+        Parameters that can be configured on Windows nodes.
+        """
+        return pulumi.get(self, "windows_node_config")
+
+    @windows_node_config.setter
+    def windows_node_config(self, value: Optional[pulumi.Input['NodePoolNodeConfigWindowsNodeConfigArgs']]):
+        pulumi.set(self, "windows_node_config", value)
+
     @property
     @pulumi.getter(name="workloadMetadataConfig")
     def workload_metadata_config(self) -> Optional[pulumi.Input['NodePoolNodeConfigWorkloadMetadataConfigArgs']]:
@@ -19659,6 +19888,38 @@ class NodePoolNodeConfigTaintArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class NodePoolNodeConfigWindowsNodeConfigArgsDict(TypedDict):
+        osversion: NotRequired[pulumi.Input[str]]
+        """
+        The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+elif False:
+    NodePoolNodeConfigWindowsNodeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NodePoolNodeConfigWindowsNodeConfigArgs:
+    def __init__(__self__, *,
+                 osversion: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] osversion: The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+        if osversion is not None:
+            pulumi.set(__self__, "osversion", osversion)
+
+    @property
+    @pulumi.getter
+    def osversion(self) -> Optional[pulumi.Input[str]]:
+        """
+        The OS Version of the windows nodepool.Values are OS_VERSION_UNSPECIFIED,OS_VERSION_LTSC2019 and OS_VERSION_LTSC2022
+        """
+        return pulumi.get(self, "osversion")
+
+    @osversion.setter
+    def osversion(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "osversion", value)
+
+
 if not MYPY:
     class NodePoolNodeConfigWorkloadMetadataConfigArgsDict(TypedDict):
         mode: pulumi.Input[str]