pulumi-gcp 8.36.0a1750484065__py3-none-any.whl → 8.37.0a1751903932__py3-none-any.whl

pulumi_gcp/container/outputs.py

@@ -128,6 +128,7 @@ __all__ = [
     'ClusterEnterpriseConfig',
     'ClusterFleet',
     'ClusterGatewayApiConfig',
+    'ClusterGkeAutoUpgradeConfig',
     'ClusterIdentityServiceConfig',
     'ClusterIpAllocationPolicy',
     'ClusterIpAllocationPolicyAdditionalPodRangesConfig',
@@ -337,6 +338,7 @@ __all__ = [
     'GetClusterEnterpriseConfigResult',
     'GetClusterFleetResult',
     'GetClusterGatewayApiConfigResult',
+    'GetClusterGkeAutoUpgradeConfigResult',
     'GetClusterIdentityServiceConfigResult',
     'GetClusterIpAllocationPolicyResult',
     'GetClusterIpAllocationPolicyAdditionalPodRangesConfigResult',
@@ -5365,13 +5367,35 @@ class ClusterClusterTelemetry(dict):
 
 @pulumi.output_type
 class ClusterConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param builtins.str confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -5382,6 +5406,15 @@ class ClusterConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class ClusterControlPlaneEndpointsConfig(dict):
@@ -5860,6 +5893,45 @@ class ClusterGatewayApiConfig(dict):
         return pulumi.get(self, "channel")
 
 
+@pulumi.output_type
+class ClusterGkeAutoUpgradeConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "patchMode":
+            suggest = "patch_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeAutoUpgradeConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterGkeAutoUpgradeConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterGkeAutoUpgradeConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 patch_mode: builtins.str):
+        """
+        :param builtins.str patch_mode: The selected patch mode.
+               Accepted values are:
+               * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        pulumi.set(__self__, "patch_mode", patch_mode)
+
+    @property
+    @pulumi.getter(name="patchMode")
+    def patch_mode(self) -> builtins.str:
+        """
+        The selected patch mode.
+        Accepted values are:
+        * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        return pulumi.get(self, "patch_mode")
+
+
 @pulumi.output_type
 class ClusterIdentityServiceConfig(dict):
     def __init__(__self__, *,
@@ -7773,6 +7845,8 @@ class ClusterNodeConfigAdvancedMachineFeatures(dict):
             suggest = "threads_per_core"
         elif key == "enableNestedVirtualization":
             suggest = "enable_nested_virtualization"
+        elif key == "performanceMonitoringUnit":
+            suggest = "performance_monitoring_unit"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigAdvancedMachineFeatures. Access the value via the '{suggest}' property getter instead.")
@@ -7787,14 +7861,18 @@ class ClusterNodeConfigAdvancedMachineFeatures(dict):
 
     def __init__(__self__, *,
                  threads_per_core: builtins.int,
-                 enable_nested_virtualization: Optional[builtins.bool] = None):
+                 enable_nested_virtualization: Optional[builtins.bool] = None,
+                 performance_monitoring_unit: Optional[builtins.str] = None):
         """
         :param builtins.int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         :param builtins.bool enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
+        :param builtins.str performance_monitoring_unit: Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
         """
         pulumi.set(__self__, "threads_per_core", threads_per_core)
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        if performance_monitoring_unit is not None:
+            pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
 
     @property
     @pulumi.getter(name="threadsPerCore")
@@ -7812,16 +7890,46 @@ class ClusterNodeConfigAdvancedMachineFeatures(dict):
         """
         return pulumi.get(self, "enable_nested_virtualization")
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> Optional[builtins.str]:
+        """
+        Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
 
 @pulumi.output_type
 class ClusterNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param builtins.str confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -7832,6 +7940,15 @@ class ClusterNodeConfigConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class ClusterNodeConfigContainerdConfig(dict):
@@ -10098,12 +10215,12 @@ class ClusterNodePoolNetworkConfig(dict):
         """
         :param Sequence['ClusterNodePoolNetworkConfigAdditionalNodeNetworkConfigArgs'] additional_node_network_configs: We specify the additional node networks for this node pool using this list. Each node network corresponds to an additional interface
         :param Sequence['ClusterNodePoolNetworkConfigAdditionalPodNetworkConfigArgs'] additional_pod_network_configs: We specify the additional pod networks for this node pool using this list. Each pod network corresponds to an additional alias IP range for the node
-        :param builtins.bool create_pod_range: Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified.
+        :param builtins.bool create_pod_range: Whether to create a new range for pod IPs in this node pool. Defaults are provided for pod_range and pod_ipv4_cidr_block if they are not specified.
         :param builtins.bool enable_private_nodes: Whether nodes have internal IP addresses only.
         :param 'ClusterNodePoolNetworkConfigNetworkPerformanceConfigArgs' network_performance_config: Network bandwidth tier configuration.
         :param 'ClusterNodePoolNetworkConfigPodCidrOverprovisionConfigArgs' pod_cidr_overprovision_config: Configuration for node-pool level pod cidr overprovision. If not set, the cluster level setting will be inherited
-        :param builtins.str pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if createPodRange is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) to pick a specific range to use.
-        :param builtins.str pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID.
+        :param builtins.str pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if create_pod_range is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) to pick a specific range to use.
+        :param builtins.str pod_range: The ID of the secondary range for pod IPs. If create_pod_range is true, this ID is used for the new range. If create_pod_range is false, uses an existing secondary range with this ID.
         """
         if additional_node_network_configs is not None:
             pulumi.set(__self__, "additional_node_network_configs", additional_node_network_configs)
@@ -10142,7 +10259,7 @@ class ClusterNodePoolNetworkConfig(dict):
     @pulumi.getter(name="createPodRange")
     def create_pod_range(self) -> Optional[builtins.bool]:
         """
-        Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified.
+        Whether to create a new range for pod IPs in this node pool. Defaults are provided for pod_range and pod_ipv4_cidr_block if they are not specified.
         """
         return pulumi.get(self, "create_pod_range")
 
@@ -10174,7 +10291,7 @@ class ClusterNodePoolNetworkConfig(dict):
     @pulumi.getter(name="podIpv4CidrBlock")
     def pod_ipv4_cidr_block(self) -> Optional[builtins.str]:
         """
-        The IP address range for pod IPs in this node pool. Only applicable if createPodRange is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) to pick a specific range to use.
+        The IP address range for pod IPs in this node pool. Only applicable if create_pod_range is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) to pick a specific range to use.
         """
         return pulumi.get(self, "pod_ipv4_cidr_block")
 
@@ -10182,7 +10299,7 @@ class ClusterNodePoolNetworkConfig(dict):
     @pulumi.getter(name="podRange")
     def pod_range(self) -> Optional[builtins.str]:
         """
-        The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID.
+        The ID of the secondary range for pod IPs. If create_pod_range is true, this ID is used for the new range. If create_pod_range is false, uses an existing secondary range with this ID.
         """
         return pulumi.get(self, "pod_range")
 
@@ -11114,6 +11231,8 @@ class ClusterNodePoolNodeConfigAdvancedMachineFeatures(dict):
             suggest = "threads_per_core"
         elif key == "enableNestedVirtualization":
             suggest = "enable_nested_virtualization"
+        elif key == "performanceMonitoringUnit":
+            suggest = "performance_monitoring_unit"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigAdvancedMachineFeatures. Access the value via the '{suggest}' property getter instead.")
@@ -11128,14 +11247,18 @@ class ClusterNodePoolNodeConfigAdvancedMachineFeatures(dict):
 
     def __init__(__self__, *,
                  threads_per_core: builtins.int,
-                 enable_nested_virtualization: Optional[builtins.bool] = None):
+                 enable_nested_virtualization: Optional[builtins.bool] = None,
+                 performance_monitoring_unit: Optional[builtins.str] = None):
         """
         :param builtins.int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         :param builtins.bool enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
+        :param builtins.str performance_monitoring_unit: Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
         """
         pulumi.set(__self__, "threads_per_core", threads_per_core)
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        if performance_monitoring_unit is not None:
+            pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
 
     @property
     @pulumi.getter(name="threadsPerCore")
@@ -11153,16 +11276,46 @@ class ClusterNodePoolNodeConfigAdvancedMachineFeatures(dict):
         """
         return pulumi.get(self, "enable_nested_virtualization")
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> Optional[builtins.str]:
+        """
+        Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
 
 @pulumi.output_type
 class ClusterNodePoolNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param builtins.str confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -11173,6 +11326,15 @@ class ClusterNodePoolNodeConfigConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class ClusterNodePoolNodeConfigContainerdConfig(dict):
@@ -14323,10 +14485,7 @@ class NodePoolNodeConfig(dict):
         :param builtins.str node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on sole tenant nodes.
         :param Sequence[builtins.str] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs.
         :param builtins.bool preemptible: Whether the nodes are created as preemptible VM instances.
-        :param 'NodePoolNodeConfigReservationAffinityArgs' reservation_affinity: The configuration of the desired reservation which instances could take capacity from.
-               Structure is documented below.
-               
-               <a name="nested_autoscaling"></a>The `autoscaling` block supports (either total or per zone limits are required):
+        :param 'NodePoolNodeConfigReservationAffinityArgs' reservation_affinity: The reservation affinity configuration for the node pool.
         :param Mapping[str, builtins.str] resource_labels: The GCE resource labels (a map of key/value pairs) to be applied to the node pool.
         :param Mapping[str, builtins.str] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param 'NodePoolNodeConfigSandboxConfigArgs' sandbox_config: Sandbox configuration for this node.
@@ -14684,10 +14843,7 @@ class NodePoolNodeConfig(dict):
     @pulumi.getter(name="reservationAffinity")
     def reservation_affinity(self) -> Optional['outputs.NodePoolNodeConfigReservationAffinity']:
         """
-        The configuration of the desired reservation which instances could take capacity from.
-        Structure is documented below.
-
-        <a name="nested_autoscaling"></a>The `autoscaling` block supports (either total or per zone limits are required):
+        The reservation affinity configuration for the node pool.
         """
         return pulumi.get(self, "reservation_affinity")
 
@@ -14805,6 +14961,8 @@ class NodePoolNodeConfigAdvancedMachineFeatures(dict):
             suggest = "threads_per_core"
         elif key == "enableNestedVirtualization":
             suggest = "enable_nested_virtualization"
+        elif key == "performanceMonitoringUnit":
+            suggest = "performance_monitoring_unit"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigAdvancedMachineFeatures. Access the value via the '{suggest}' property getter instead.")
@@ -14819,14 +14977,18 @@ class NodePoolNodeConfigAdvancedMachineFeatures(dict):
 
     def __init__(__self__, *,
                  threads_per_core: builtins.int,
-                 enable_nested_virtualization: Optional[builtins.bool] = None):
+                 enable_nested_virtualization: Optional[builtins.bool] = None,
+                 performance_monitoring_unit: Optional[builtins.str] = None):
         """
         :param builtins.int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         :param builtins.bool enable_nested_virtualization: Whether the node should have nested virtualization enabled.
+        :param builtins.str performance_monitoring_unit: Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
         """
         pulumi.set(__self__, "threads_per_core", threads_per_core)
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        if performance_monitoring_unit is not None:
+            pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
 
     @property
     @pulumi.getter(name="threadsPerCore")
@@ -14844,15 +15006,44 @@ class NodePoolNodeConfigAdvancedMachineFeatures(dict):
         """
         return pulumi.get(self, "enable_nested_virtualization")
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> Optional[builtins.str]:
+        """
+        Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
 
 @pulumi.output_type
 class NodePoolNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -14862,6 +15053,14 @@ class NodePoolNodeConfigConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class NodePoolNodeConfigContainerdConfig(dict):
@@ -17333,12 +17532,23 @@ class GetClusterClusterTelemetryResult(dict):
 @pulumi.output_type
 class GetClusterConfidentialNodeResult(dict):
     def __init__(__self__, *,
+                 confidential_instance_type: builtins.str,
                  enabled: builtins.bool):
         """
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this cluster.
         """
+        pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
         pulumi.set(__self__, "enabled", enabled)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> builtins.str:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
     @property
     @pulumi.getter
     def enabled(self) -> builtins.bool:
@@ -17669,6 +17879,26 @@ class GetClusterGatewayApiConfigResult(dict):
         return pulumi.get(self, "channel")
 
 
+@pulumi.output_type
+class GetClusterGkeAutoUpgradeConfigResult(dict):
+    def __init__(__self__, *,
+                 patch_mode: builtins.str):
+        """
+        :param builtins.str patch_mode: The selected auto-upgrade patch type. Accepted values are:
+               * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        pulumi.set(__self__, "patch_mode", patch_mode)
+
+    @property
+    @pulumi.getter(name="patchMode")
+    def patch_mode(self) -> builtins.str:
+        """
+        The selected auto-upgrade patch type. Accepted values are:
+        * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        return pulumi.get(self, "patch_mode")
+
+
 @pulumi.output_type
 class GetClusterIdentityServiceConfigResult(dict):
     def __init__(__self__, *,
@@ -18786,12 +19016,15 @@ class GetClusterNodeConfigResult(dict):
 class GetClusterNodeConfigAdvancedMachineFeatureResult(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: builtins.bool,
+                 performance_monitoring_unit: builtins.str,
                  threads_per_core: builtins.int):
         """
         :param builtins.bool enable_nested_virtualization: Whether the node should have nested virtualization enabled.
+        :param builtins.str performance_monitoring_unit: Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
         :param builtins.int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         """
         pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
         pulumi.set(__self__, "threads_per_core", threads_per_core)
 
     @property
@@ -18802,6 +19035,14 @@ class GetClusterNodeConfigAdvancedMachineFeatureResult(dict):
         """
         return pulumi.get(self, "enable_nested_virtualization")
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> builtins.str:
+        """
+        Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
     @property
     @pulumi.getter(name="threadsPerCore")
     def threads_per_core(self) -> builtins.int:
@@ -18814,12 +19055,23 @@ class GetClusterNodeConfigAdvancedMachineFeatureResult(dict):
 @pulumi.output_type
 class GetClusterNodeConfigConfidentialNodeResult(dict):
     def __init__(__self__, *,
+                 confidential_instance_type: builtins.str,
                  enabled: builtins.bool):
         """
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
         """
+        pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
         pulumi.set(__self__, "enabled", enabled)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> builtins.str:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
     @property
     @pulumi.getter
     def enabled(self) -> builtins.bool:
@@ -20923,12 +21175,15 @@ class GetClusterNodePoolNodeConfigResult(dict):
 class GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult(dict):
     def __init__(__self__, *,
                  enable_nested_virtualization: builtins.bool,
+                 performance_monitoring_unit: builtins.str,
                  threads_per_core: builtins.int):
         """
         :param builtins.bool enable_nested_virtualization: Whether the node should have nested virtualization enabled.
+        :param builtins.str performance_monitoring_unit: Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
         :param builtins.int threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         """
         pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
         pulumi.set(__self__, "threads_per_core", threads_per_core)
 
     @property
@@ -20939,6 +21194,14 @@ class GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult(dict):
         """
         return pulumi.get(self, "enable_nested_virtualization")
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> builtins.str:
+        """
+        Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
     @property
     @pulumi.getter(name="threadsPerCore")
     def threads_per_core(self) -> builtins.int:
@@ -20951,12 +21214,23 @@ class GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult(dict):
 @pulumi.output_type
 class GetClusterNodePoolNodeConfigConfidentialNodeResult(dict):
     def __init__(__self__, *,
+                 confidential_instance_type: builtins.str,
                  enabled: builtins.bool):
         """
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
         """
+        pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
         pulumi.set(__self__, "enabled", enabled)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> builtins.str:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
     @property
     @pulumi.getter
     def enabled(self) -> builtins.bool: