pulumi-alicloud 3.51.0a1710157550__py3-none-any.whl → 3.73.0a1736832142__py3-none-any.whl

pulumi_alicloud/cs/_inputs.py

@@ -4,48 +4,120 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'ApplicationServiceArgs',
+    'ApplicationServiceArgsDict',
     'ClusterNodeArgs',
+    'ClusterNodeArgsDict',
     'EdgeKubernetesAddonArgs',
+    'EdgeKubernetesAddonArgsDict',
     'EdgeKubernetesCertificateAuthorityArgs',
+    'EdgeKubernetesCertificateAuthorityArgsDict',
     'EdgeKubernetesConnectionsArgs',
+    'EdgeKubernetesConnectionsArgsDict',
     'EdgeKubernetesLogConfigArgs',
+    'EdgeKubernetesLogConfigArgsDict',
     'EdgeKubernetesRuntimeArgs',
+    'EdgeKubernetesRuntimeArgsDict',
     'EdgeKubernetesWorkerDataDiskArgs',
+    'EdgeKubernetesWorkerDataDiskArgsDict',
     'EdgeKubernetesWorkerNodeArgs',
+    'EdgeKubernetesWorkerNodeArgsDict',
     'KubernetesAddonArgs',
+    'KubernetesAddonArgsDict',
     'KubernetesAutoscalerNodepoolArgs',
+    'KubernetesAutoscalerNodepoolArgsDict',
     'KubernetesCertificateAuthorityArgs',
+    'KubernetesCertificateAuthorityArgsDict',
     'KubernetesConnectionsArgs',
+    'KubernetesConnectionsArgsDict',
+    'KubernetesDeleteOptionArgs',
+    'KubernetesDeleteOptionArgsDict',
     'KubernetesMasterNodeArgs',
+    'KubernetesMasterNodeArgsDict',
     'KubernetesPermissionPermissionArgs',
+    'KubernetesPermissionPermissionArgsDict',
     'KubernetesRuntimeArgs',
+    'KubernetesRuntimeArgsDict',
     'ManagedKubernetesAddonArgs',
+    'ManagedKubernetesAddonArgsDict',
     'ManagedKubernetesCertificateAuthorityArgs',
+    'ManagedKubernetesCertificateAuthorityArgsDict',
     'ManagedKubernetesConnectionsArgs',
+    'ManagedKubernetesConnectionsArgsDict',
+    'ManagedKubernetesDeleteOptionArgs',
+    'ManagedKubernetesDeleteOptionArgsDict',
     'ManagedKubernetesMaintenanceWindowArgs',
+    'ManagedKubernetesMaintenanceWindowArgsDict',
+    'ManagedKubernetesOperationPolicyArgs',
+    'ManagedKubernetesOperationPolicyArgsDict',
+    'ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs',
+    'ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict',
     'ManagedKubernetesRrsaMetadataArgs',
+    'ManagedKubernetesRrsaMetadataArgsDict',
     'NodePoolDataDiskArgs',
+    'NodePoolDataDiskArgsDict',
     'NodePoolKubeletConfigurationArgs',
+    'NodePoolKubeletConfigurationArgsDict',
     'NodePoolLabelArgs',
+    'NodePoolLabelArgsDict',
     'NodePoolManagementArgs',
+    'NodePoolManagementArgsDict',
+    'NodePoolManagementAutoRepairPolicyArgs',
+    'NodePoolManagementAutoRepairPolicyArgsDict',
+    'NodePoolManagementAutoUpgradePolicyArgs',
+    'NodePoolManagementAutoUpgradePolicyArgsDict',
+    'NodePoolManagementAutoVulFixPolicyArgs',
+    'NodePoolManagementAutoVulFixPolicyArgsDict',
+    'NodePoolPrivatePoolOptionsArgs',
+    'NodePoolPrivatePoolOptionsArgsDict',
     'NodePoolRollingPolicyArgs',
-    'NodePoolRolloutPolicyArgs',
+    'NodePoolRollingPolicyArgsDict',
     'NodePoolScalingConfigArgs',
+    'NodePoolScalingConfigArgsDict',
     'NodePoolSpotPriceLimitArgs',
+    'NodePoolSpotPriceLimitArgsDict',
     'NodePoolTaintArgs',
+    'NodePoolTaintArgsDict',
+    'NodePoolTeeConfigArgs',
+    'NodePoolTeeConfigArgsDict',
     'ServerlessKubernetesAddonArgs',
+    'ServerlessKubernetesAddonArgsDict',
+    'ServerlessKubernetesDeleteOptionArgs',
+    'ServerlessKubernetesDeleteOptionArgsDict',
+    'ServerlessKubernetesMaintenanceWindowArgs',
+    'ServerlessKubernetesMaintenanceWindowArgsDict',
+    'ServerlessKubernetesOperationPolicyArgs',
+    'ServerlessKubernetesOperationPolicyArgsDict',
+    'ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs',
+    'ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict',
     'ServerlessKubernetesRrsaMetadataArgs',
+    'ServerlessKubernetesRrsaMetadataArgsDict',
     'SwarmNodeArgs',
-    'GetKubernetesPermissionPermissionArgs',
+    'SwarmNodeArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class ApplicationServiceArgsDict(TypedDict):
+        id: NotRequired[pulumi.Input[str]]
+        name: NotRequired[pulumi.Input[str]]
+        status: NotRequired[pulumi.Input[str]]
+        version: NotRequired[pulumi.Input[str]]
+elif False:
+    ApplicationServiceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ApplicationServiceArgs:
     def __init__(__self__, *,
@@ -99,6 +171,16 @@ class ApplicationServiceArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class ClusterNodeArgsDict(TypedDict):
+        eip: NotRequired[pulumi.Input[str]]
+        id: NotRequired[pulumi.Input[str]]
+        name: NotRequired[pulumi.Input[str]]
+        private_ip: NotRequired[pulumi.Input[str]]
+        status: NotRequired[pulumi.Input[str]]
+elif False:
+    ClusterNodeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ClusterNodeArgs:
     def __init__(__self__, *,
@@ -164,18 +246,65 @@ class ClusterNodeArgs:
         pulumi.set(self, "status", value)
 
 
+if not MYPY:
+    class EdgeKubernetesAddonArgsDict(TypedDict):
+        config: NotRequired[pulumi.Input[str]]
+        """
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
+        """
+        disabled: NotRequired[pulumi.Input[bool]]
+        """
+        Disables the automatic installation of a component. Default is `false`.
+
+        The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with SLB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        ```
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        It specifies the version of the component.
+        """
+elif False:
+    EdgeKubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EdgeKubernetesAddonArgs:
     def __init__(__self__, *,
                  config: Optional[pulumi.Input[str]] = None,
                  disabled: Optional[pulumi.Input[bool]] = None,
-                 name: Optional[pulumi.Input[str]] = None):
+                 name: Optional[pulumi.Input[str]] = None,
+                 version: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] config: The ACK add-on configurations.
+        :param pulumi.Input[str] config: The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         :param pulumi.Input[bool] disabled: Disables the automatic installation of a component. Default is `false`.
                
                The following example is the definition of addons block, The type of this field is list:
+               
+               ```
+               # install nginx ingress, conflict with SLB ingress
+               addons {
+               name = "nginx-ingress-controller"
+               # use internet
+               config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               # if use intranet, detail below.
+               # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               }
+               ```
         :param pulumi.Input[str] name: Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
+        :param pulumi.Input[str] version: It specifies the version of the component.
         """
         if config is not None:
             pulumi.set(__self__, "config", config)
@@ -183,12 +312,14 @@ class EdgeKubernetesAddonArgs:
             pulumi.set(__self__, "disabled", disabled)
         if name is not None:
             pulumi.set(__self__, "name", name)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
 
     @property
     @pulumi.getter
     def config(self) -> Optional[pulumi.Input[str]]:
         """
-        The ACK add-on configurations.
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -203,6 +334,17 @@ class EdgeKubernetesAddonArgs:
         Disables the automatic installation of a component. Default is `false`.
 
         The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with SLB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        ```
         """
         return pulumi.get(self, "disabled")
 
@@ -222,6 +364,35 @@ class EdgeKubernetesAddonArgs:
     def name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "name", value)
 
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[str]]:
+        """
+        It specifies the version of the component.
+        """
+        return pulumi.get(self, "version")
+
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "version", value)
+
+
+if not MYPY:
+    class EdgeKubernetesCertificateAuthorityArgsDict(TypedDict):
+        client_cert: NotRequired[pulumi.Input[str]]
+        """
+        The path of client certificate, like `~/.kube/client-cert.pem`.
+        """
+        client_key: NotRequired[pulumi.Input[str]]
+        """
+        The path of client key, like `~/.kube/client-key.pem`.
+        """
+        cluster_cert: NotRequired[pulumi.Input[str]]
+        """
+        The base64 encoded cluster certificate data required to communicate with your cluster. Add this to the certificate-authority-data section of the kubeconfig file for your cluster.
+        """
+elif False:
+    EdgeKubernetesCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class EdgeKubernetesCertificateAuthorityArgs:
@@ -278,6 +449,27 @@ class EdgeKubernetesCertificateAuthorityArgs:
         pulumi.set(self, "cluster_cert", value)
 
 
+if not MYPY:
+    class EdgeKubernetesConnectionsArgsDict(TypedDict):
+        api_server_internet: NotRequired[pulumi.Input[str]]
+        """
+        API Server Internet endpoint.
+        """
+        api_server_intranet: NotRequired[pulumi.Input[str]]
+        """
+        API Server Intranet endpoint.
+        """
+        master_public_ip: NotRequired[pulumi.Input[str]]
+        """
+        Master node SSH IP address.
+        """
+        service_domain: NotRequired[pulumi.Input[str]]
+        """
+        Service Access Domain.
+        """
+elif False:
+    EdgeKubernetesConnectionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EdgeKubernetesConnectionsArgs:
     def __init__(__self__, *,
@@ -349,6 +541,19 @@ class EdgeKubernetesConnectionsArgs:
         pulumi.set(self, "service_domain", value)
 
 
+if not MYPY:
+    class EdgeKubernetesLogConfigArgsDict(TypedDict):
+        type: pulumi.Input[str]
+        """
+        Type of collecting logs, only `SLS` are supported currently.
+        """
+        project: NotRequired[pulumi.Input[str]]
+        """
+        Log Service project name, cluster logs will output to this project.
+        """
+elif False:
+    EdgeKubernetesLogConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EdgeKubernetesLogConfigArgs:
     def __init__(__self__, *,
@@ -387,14 +592,45 @@ class EdgeKubernetesLogConfigArgs:
         pulumi.set(self, "project", value)
 
 
+if not MYPY:
+    class EdgeKubernetesRuntimeArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        The version of the runtime.
+
+        The following example is the definition of runtime block:
+
+        ```
+        runtime = {
+        name = "containerd"
+        version = "1.6.28"
+        }
+        ```
+        """
+elif False:
+    EdgeKubernetesRuntimeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EdgeKubernetesRuntimeArgs:
     def __init__(__self__, *,
                  name: Optional[pulumi.Input[str]] = None,
                  version: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] name: The kubernetes cluster's name. It is unique in one Alicloud account.
-        :param pulumi.Input[str] version: Desired Kubernetes version. If you do not specify a value, the latest available version at resource creation is used and no upgrades will occur except you set a higher version number. The value must be configured and increased to upgrade the version when desired. Downgrades are not supported by ACK.
+        :param pulumi.Input[str] name: The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
+        :param pulumi.Input[str] version: The version of the runtime.
+               
+               The following example is the definition of runtime block:
+               
+               ```
+               runtime = {
+               name = "containerd"
+               version = "1.6.28"
+               }
+               ```
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -405,7 +641,7 @@ class EdgeKubernetesRuntimeArgs:
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
         """
-        The kubernetes cluster's name. It is unique in one Alicloud account.
+        The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
         """
         return pulumi.get(self, "name")
 
@@ -417,7 +653,16 @@ class EdgeKubernetesRuntimeArgs:
     @pulumi.getter
     def version(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired Kubernetes version. If you do not specify a value, the latest available version at resource creation is used and no upgrades will occur except you set a higher version number. The value must be configured and increased to upgrade the version when desired. Downgrades are not supported by ACK.
+        The version of the runtime.
+
+        The following example is the definition of runtime block:
+
+        ```
+        runtime = {
+        name = "containerd"
+        version = "1.6.28"
+        }
+        ```
         """
         return pulumi.get(self, "version")
 
@@ -426,6 +671,47 @@ class EdgeKubernetesRuntimeArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class EdgeKubernetesWorkerDataDiskArgsDict(TypedDict):
+        auto_snapshot_policy_id: NotRequired[pulumi.Input[str]]
+        """
+        Worker node data disk auto snapshot policy.
+        """
+        category: NotRequired[pulumi.Input[str]]
+        """
+        The type of the data disks. Valid values: `cloud`, `cloud_efficiency`, `cloud_ssd` and `cloud_essd`. Default to `cloud_efficiency`.
+        """
+        device: NotRequired[pulumi.Input[str]]
+        """
+        The device of the data disks.
+        """
+        encrypted: NotRequired[pulumi.Input[str]]
+        """
+        Specifies whether to encrypt data disks. Valid values: true and false. Default is `false`.
+        """
+        kms_key_id: NotRequired[pulumi.Input[str]]
+        """
+        The id of the kms key.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the data disks.
+        """
+        performance_level: NotRequired[pulumi.Input[str]]
+        """
+        Worker node data disk performance level, when `category` values `cloud_essd`, the optional values are `PL0`, `PL1`, `PL2` or `PL3`, but the specific performance level is related to the disk capacity. For more information, see [Enhanced SSDs](https://www.alibabacloud.com/help/doc-detail/122389.htm). Default is `PL1`.
+        """
+        size: NotRequired[pulumi.Input[str]]
+        """
+        The size of a data disk, at least 40. Unit: GiB.
+        """
+        snapshot_id: NotRequired[pulumi.Input[str]]
+        """
+        The id of snapshot.
+        """
+elif False:
+    EdgeKubernetesWorkerDataDiskArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EdgeKubernetesWorkerDataDiskArgs:
     def __init__(__self__, *,
@@ -577,6 +863,23 @@ class EdgeKubernetesWorkerDataDiskArgs:
         pulumi.set(self, "snapshot_id", value)
 
 
+if not MYPY:
+    class EdgeKubernetesWorkerNodeArgsDict(TypedDict):
+        id: NotRequired[pulumi.Input[str]]
+        """
+        ID of the node.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The kubernetes cluster's name. It is unique in one Alicloud account.
+        """
+        private_ip: NotRequired[pulumi.Input[str]]
+        """
+        The private IP address of node.
+        """
+elif False:
+    EdgeKubernetesWorkerNodeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EdgeKubernetesWorkerNodeArgs:
     def __init__(__self__, *,
@@ -632,6 +935,40 @@ class EdgeKubernetesWorkerNodeArgs:
         pulumi.set(self, "private_ip", value)
 
 
+if not MYPY:
+    class KubernetesAddonArgsDict(TypedDict):
+        config: NotRequired[pulumi.Input[str]]
+        """
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
+        """
+        disabled: NotRequired[pulumi.Input[bool]]
+        """
+        Disables the automatic installation of a component. Default is `false`.
+
+        The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with SLB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        ```
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        The version of the component.
+        """
+elif False:
+    KubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class KubernetesAddonArgs:
     def __init__(__self__, *,
@@ -640,10 +977,21 @@ class KubernetesAddonArgs:
                  name: Optional[pulumi.Input[str]] = None,
                  version: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] config: The ACK add-on configurations.
+        :param pulumi.Input[str] config: The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         :param pulumi.Input[bool] disabled: Disables the automatic installation of a component. Default is `false`.
                
                The following example is the definition of addons block, The type of this field is list:
+               
+               ```
+               # install nginx ingress, conflict with SLB ingress
+               addons {
+               name = "nginx-ingress-controller"
+               # use internet
+               config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               # if use intranet, detail below.
+               # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               }
+               ```
         :param pulumi.Input[str] name: Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
         :param pulumi.Input[str] version: The version of the component.
         """
@@ -660,7 +1008,7 @@ class KubernetesAddonArgs:
     @pulumi.getter
     def config(self) -> Optional[pulumi.Input[str]]:
         """
-        The ACK add-on configurations.
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -675,6 +1023,17 @@ class KubernetesAddonArgs:
         Disables the automatic installation of a component. Default is `false`.
 
         The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with SLB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        ```
         """
         return pulumi.get(self, "disabled")
 
@@ -707,6 +1066,23 @@ class KubernetesAddonArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class KubernetesAutoscalerNodepoolArgsDict(TypedDict):
+        id: NotRequired[pulumi.Input[str]]
+        """
+        The scaling group id of the groups configured for cluster-autoscaler.
+        """
+        labels: NotRequired[pulumi.Input[str]]
+        """
+        The labels for the nodes in scaling group.
+        """
+        taints: NotRequired[pulumi.Input[str]]
+        """
+        The taints for the nodes in scaling group.
+        """
+elif False:
+    KubernetesAutoscalerNodepoolArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class KubernetesAutoscalerNodepoolArgs:
     def __init__(__self__, *,
@@ -762,6 +1138,23 @@ class KubernetesAutoscalerNodepoolArgs:
         pulumi.set(self, "taints", value)
 
 
+if not MYPY:
+    class KubernetesCertificateAuthorityArgsDict(TypedDict):
+        client_cert: NotRequired[pulumi.Input[str]]
+        """
+        The path of client certificate, like `~/.kube/client-cert.pem`.
+        """
+        client_key: NotRequired[pulumi.Input[str]]
+        """
+        The path of client key, like `~/.kube/client-key.pem`.
+        """
+        cluster_cert: NotRequired[pulumi.Input[str]]
+        """
+        The base64 encoded cluster certificate data required to communicate with your cluster. Add this to the certificate-authority-data section of the kubeconfig file for your cluster.
+        """
+elif False:
+    KubernetesCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class KubernetesCertificateAuthorityArgs:
     def __init__(__self__, *,
@@ -817,6 +1210,27 @@ class KubernetesCertificateAuthorityArgs:
         pulumi.set(self, "cluster_cert", value)
 
 
+if not MYPY:
+    class KubernetesConnectionsArgsDict(TypedDict):
+        api_server_internet: NotRequired[pulumi.Input[str]]
+        """
+        API Server Internet endpoint.
+        """
+        api_server_intranet: NotRequired[pulumi.Input[str]]
+        """
+        API Server Intranet endpoint.
+        """
+        master_public_ip: NotRequired[pulumi.Input[str]]
+        """
+        Master node SSH IP address.
+        """
+        service_domain: NotRequired[pulumi.Input[str]]
+        """
+        Service Access Domain.
+        """
+elif False:
+    KubernetesConnectionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class KubernetesConnectionsArgs:
     def __init__(__self__, *,
@@ -888,6 +1302,162 @@ class KubernetesConnectionsArgs:
         pulumi.set(self, "service_domain", value)
 
 
+if not MYPY:
+    class KubernetesDeleteOptionArgsDict(TypedDict):
+        delete_mode: NotRequired[pulumi.Input[str]]
+        """
+        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of resources that are created by cluster. Valid values:
+        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+
+        ```
+        ...
+        // Specify delete_options as below when deleting cluster
+        // delete SLB resources created by the Nginx Ingress Service
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLB"
+        }
+        // delete ALB resources created by the ALB Ingress Controller
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "ALB"
+        }
+        // delete SLS Project used by the cluster logging feature
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_Data"
+        }
+        // delete SLS Project used for the managed cluster control plane logs
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_ControlPlane"
+        }
+        ```
+        """
+elif False:
+    KubernetesDeleteOptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class KubernetesDeleteOptionArgs:
+    def __init__(__self__, *,
+                 delete_mode: Optional[pulumi.Input[str]] = None,
+                 resource_type: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] delete_mode: The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        :param pulumi.Input[str] resource_type: The type of resources that are created by cluster. Valid values:
+               - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+               - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+               - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+               - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+               
+               ```
+               ...
+               // Specify delete_options as below when deleting cluster
+               // delete SLB resources created by the Nginx Ingress Service
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLB"
+               }
+               // delete ALB resources created by the ALB Ingress Controller
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "ALB"
+               }
+               // delete SLS Project used by the cluster logging feature
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLS_Data"
+               }
+               // delete SLS Project used for the managed cluster control plane logs
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLS_ControlPlane"
+               }
+               ```
+        """
+        if delete_mode is not None:
+            pulumi.set(__self__, "delete_mode", delete_mode)
+        if resource_type is not None:
+            pulumi.set(__self__, "resource_type", resource_type)
+
+    @property
+    @pulumi.getter(name="deleteMode")
+    def delete_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        """
+        return pulumi.get(self, "delete_mode")
+
+    @delete_mode.setter
+    def delete_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delete_mode", value)
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        The type of resources that are created by cluster. Valid values:
+        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+
+        ```
+        ...
+        // Specify delete_options as below when deleting cluster
+        // delete SLB resources created by the Nginx Ingress Service
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLB"
+        }
+        // delete ALB resources created by the ALB Ingress Controller
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "ALB"
+        }
+        // delete SLS Project used by the cluster logging feature
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_Data"
+        }
+        // delete SLS Project used for the managed cluster control plane logs
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_ControlPlane"
+        }
+        ```
+        """
+        return pulumi.get(self, "resource_type")
+
+    @resource_type.setter
+    def resource_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_type", value)
+
+
+if not MYPY:
+    class KubernetesMasterNodeArgsDict(TypedDict):
+        id: NotRequired[pulumi.Input[str]]
+        """
+        ID of the node.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The kubernetes cluster's name. It is unique in one Alicloud account.
+        """
+        private_ip: NotRequired[pulumi.Input[str]]
+        """
+        The private IP address of node.
+        """
+elif False:
+    KubernetesMasterNodeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class KubernetesMasterNodeArgs:
     def __init__(__self__, *,
@@ -943,6 +1513,35 @@ class KubernetesMasterNodeArgs:
         pulumi.set(self, "private_ip", value)
 
 
+if not MYPY:
+    class KubernetesPermissionPermissionArgsDict(TypedDict):
+        cluster: pulumi.Input[str]
+        """
+        The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `cluster` must be `""`.
+        """
+        role_name: pulumi.Input[str]
+        """
+        Specifies the predefined role that you want to assign. Valid values `admin`, `ops`, `dev`, `restricted` and the custom cluster roles.
+        """
+        role_type: pulumi.Input[str]
+        """
+        The authorization type. Valid values `cluster`, `namespace` and `all-clusters`.
+        """
+        is_custom: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to perform a custom authorization. To perform a custom authorization, the value of `is_custom` must be `true`, and set `role_name` to a custom cluster role.
+        """
+        is_ram_role: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether the permissions are granted to a RAM role. When `uid` is ram role id, the value of `is_ram_role` must be `true`.
+        """
+        namespace: NotRequired[pulumi.Input[str]]
+        """
+        The namespace to which the permissions are scoped. This parameter is required only if you set role_type to namespace.
+        """
+elif False:
+    KubernetesPermissionPermissionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class KubernetesPermissionPermissionArgs:
     def __init__(__self__, *,
@@ -953,10 +1552,10 @@ class KubernetesPermissionPermissionArgs:
                  is_ram_role: Optional[pulumi.Input[bool]] = None,
                  namespace: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] cluster: The ID of the cluster that you want to manage.
+        :param pulumi.Input[str] cluster: The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `cluster` must be `""`.
         :param pulumi.Input[str] role_name: Specifies the predefined role that you want to assign. Valid values `admin`, `ops`, `dev`, `restricted` and the custom cluster roles.
-        :param pulumi.Input[str] role_type: The authorization type. Valid values `cluster`, `namespace`.
-        :param pulumi.Input[bool] is_custom: Specifies whether to perform a custom authorization. To perform a custom authorization, set `role_name` to a custom cluster role.
+        :param pulumi.Input[str] role_type: The authorization type. Valid values `cluster`, `namespace` and `all-clusters`.
+        :param pulumi.Input[bool] is_custom: Specifies whether to perform a custom authorization. To perform a custom authorization, the value of `is_custom` must be `true`, and set `role_name` to a custom cluster role.
         :param pulumi.Input[bool] is_ram_role: Specifies whether the permissions are granted to a RAM role. When `uid` is ram role id, the value of `is_ram_role` must be `true`.
         :param pulumi.Input[str] namespace: The namespace to which the permissions are scoped. This parameter is required only if you set role_type to namespace.
         """
@@ -974,7 +1573,7 @@ class KubernetesPermissionPermissionArgs:
     @pulumi.getter
     def cluster(self) -> pulumi.Input[str]:
         """
-        The ID of the cluster that you want to manage.
+        The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `cluster` must be `""`.
         """
         return pulumi.get(self, "cluster")
 
@@ -998,7 +1597,7 @@ class KubernetesPermissionPermissionArgs:
     @pulumi.getter(name="roleType")
     def role_type(self) -> pulumi.Input[str]:
         """
-        The authorization type. Valid values `cluster`, `namespace`.
+        The authorization type. Valid values `cluster`, `namespace` and `all-clusters`.
         """
         return pulumi.get(self, "role_type")
 
@@ -1010,7 +1609,7 @@ class KubernetesPermissionPermissionArgs:
     @pulumi.getter(name="isCustom")
     def is_custom(self) -> Optional[pulumi.Input[bool]]:
         """
-        Specifies whether to perform a custom authorization. To perform a custom authorization, set `role_name` to a custom cluster role.
+        Specifies whether to perform a custom authorization. To perform a custom authorization, the value of `is_custom` must be `true`, and set `role_name` to a custom cluster role.
         """
         return pulumi.get(self, "is_custom")
 
@@ -1043,15 +1642,46 @@ class KubernetesPermissionPermissionArgs:
         pulumi.set(self, "namespace", value)
 
 
+if not MYPY:
+    class KubernetesRuntimeArgsDict(TypedDict):
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        The version of the runtime.
+
+        The following example is the definition of runtime block:
+
+        ```
+        runtime = {
+        name = "containerd"
+        version = "1.6.28"
+        }
+        ```
+        """
+elif False:
+    KubernetesRuntimeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class KubernetesRuntimeArgs:
     def __init__(__self__, *,
                  name: Optional[pulumi.Input[str]] = None,
                  version: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] name: The kubernetes cluster's name. It is unique in one Alicloud account.
-        :param pulumi.Input[str] version: Desired Kubernetes version. If you do not specify a value, the latest available version at resource creation is used and no upgrades will occur except you set a higher version number. The value must be configured and increased to upgrade the version when desired. Downgrades are not supported by ACK.
-        """
+        :param pulumi.Input[str] name: The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
+        :param pulumi.Input[str] version: The version of the runtime.
+               
+               The following example is the definition of runtime block:
+               
+               ```
+               runtime = {
+               name = "containerd"
+               version = "1.6.28"
+               }
+               ```
+        """
         if name is not None:
             pulumi.set(__self__, "name", name)
         if version is not None:
@@ -1061,7 +1691,7 @@ class KubernetesRuntimeArgs:
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
         """
-        The kubernetes cluster's name. It is unique in one Alicloud account.
+        The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
         """
         return pulumi.get(self, "name")
 
@@ -1073,7 +1703,16 @@ class KubernetesRuntimeArgs:
     @pulumi.getter
     def version(self) -> Optional[pulumi.Input[str]]:
         """
-        Desired Kubernetes version. If you do not specify a value, the latest available version at resource creation is used and no upgrades will occur except you set a higher version number. The value must be configured and increased to upgrade the version when desired. Downgrades are not supported by ACK.
+        The version of the runtime.
+
+        The following example is the definition of runtime block:
+
+        ```
+        runtime = {
+        name = "containerd"
+        version = "1.6.28"
+        }
+        ```
         """
         return pulumi.get(self, "version")
 
@@ -1082,6 +1721,37 @@ class KubernetesRuntimeArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class ManagedKubernetesAddonArgsDict(TypedDict):
+        config: NotRequired[pulumi.Input[str]]
+        """
+        If this parameter is left empty, no configurations are required. For more config information, see cs_kubernetes_addon_metadata.
+        """
+        disabled: NotRequired[pulumi.Input[bool]]
+        """
+        It specifies whether to disable automatic installation. 
+
+        It is a new field since 1.75.0. You can specific network plugin, log component,ingress component and so on.
+
+        You can get more information about addons on ACK web console. When you create a ACK cluster. You can get openapi-spec before creating the cluster on submission page.
+
+        `logtail-ds` - You can specify `IngressDashboardEnabled` and `sls_project_name` in config. If you switch on `IngressDashboardEnabled` and `sls_project_name`,then logtail-ds would use `sls_project_name` as default log store.
+
+        `nginx-ingress-controller` - You can specific `IngressSlbNetworkType` in config. Options: internet|intranet.
+
+        The `main.tf`:
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        This parameter specifies the name of the component.
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        It specifies the version of the component.
+        """
+elif False:
+    ManagedKubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedKubernetesAddonArgs:
     def __init__(__self__, *,
@@ -1090,7 +1760,7 @@ class ManagedKubernetesAddonArgs:
                  name: Optional[pulumi.Input[str]] = None,
                  version: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] config: If this parameter is left empty, no configurations are required.
+        :param pulumi.Input[str] config: If this parameter is left empty, no configurations are required. For more config information, see cs_kubernetes_addon_metadata.
         :param pulumi.Input[bool] disabled: It specifies whether to disable automatic installation. 
                
                It is a new field since 1.75.0. You can specific network plugin, log component,ingress component and so on.
@@ -1118,7 +1788,7 @@ class ManagedKubernetesAddonArgs:
     @pulumi.getter
     def config(self) -> Optional[pulumi.Input[str]]:
         """
-        If this parameter is left empty, no configurations are required.
+        If this parameter is left empty, no configurations are required. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -1173,6 +1843,23 @@ class ManagedKubernetesAddonArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class ManagedKubernetesCertificateAuthorityArgsDict(TypedDict):
+        client_cert: NotRequired[pulumi.Input[str]]
+        """
+        The path of client certificate, like `~/.kube/client-cert.pem`.
+        """
+        client_key: NotRequired[pulumi.Input[str]]
+        """
+        The path of client key, like `~/.kube/client-key.pem`.
+        """
+        cluster_cert: NotRequired[pulumi.Input[str]]
+        """
+        The base64 encoded cluster certificate data required to communicate with your cluster. Add this to the certificate-authority-data section of the kubeconfig file for your cluster.
+        """
+elif False:
+    ManagedKubernetesCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedKubernetesCertificateAuthorityArgs:
     def __init__(__self__, *,
@@ -1228,6 +1915,27 @@ class ManagedKubernetesCertificateAuthorityArgs:
         pulumi.set(self, "cluster_cert", value)
 
 
+if not MYPY:
+    class ManagedKubernetesConnectionsArgsDict(TypedDict):
+        api_server_internet: NotRequired[pulumi.Input[str]]
+        """
+        API Server Internet endpoint.
+        """
+        api_server_intranet: NotRequired[pulumi.Input[str]]
+        """
+        API Server Intranet endpoint.
+        """
+        master_public_ip: NotRequired[pulumi.Input[str]]
+        """
+        Master node SSH IP address.
+        """
+        service_domain: NotRequired[pulumi.Input[str]]
+        """
+        Service Access Domain.
+        """
+elif False:
+    ManagedKubernetesConnectionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedKubernetesConnectionsArgs:
     def __init__(__self__, *,
@@ -1299,87 +2007,402 @@ class ManagedKubernetesConnectionsArgs:
         pulumi.set(self, "service_domain", value)
 
 
+if not MYPY:
+    class ManagedKubernetesDeleteOptionArgsDict(TypedDict):
+        delete_mode: NotRequired[pulumi.Input[str]]
+        """
+        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of resources that are created by cluster. Valid values:
+        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+
+        ```
+        ...
+        // Specify delete_options as below when deleting cluster
+        // delete SLB resources created by the Nginx Ingress Service
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLB"
+        }
+        // delete ALB resources created by the ALB Ingress Controller
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "ALB"
+        }
+        // delete SLS Project used by the cluster logging feature
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_Data"
+        }
+        // delete SLS Project used for the managed cluster control plane logs
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_ControlPlane"
+        }
+        ```
+        """
+elif False:
+    ManagedKubernetesDeleteOptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ManagedKubernetesDeleteOptionArgs:
+    def __init__(__self__, *,
+                 delete_mode: Optional[pulumi.Input[str]] = None,
+                 resource_type: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] delete_mode: The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        :param pulumi.Input[str] resource_type: The type of resources that are created by cluster. Valid values:
+               - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+               - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+               - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+               - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+               
+               ```
+               ...
+               // Specify delete_options as below when deleting cluster
+               // delete SLB resources created by the Nginx Ingress Service
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLB"
+               }
+               // delete ALB resources created by the ALB Ingress Controller
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "ALB"
+               }
+               // delete SLS Project used by the cluster logging feature
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLS_Data"
+               }
+               // delete SLS Project used for the managed cluster control plane logs
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLS_ControlPlane"
+               }
+               ```
+        """
+        if delete_mode is not None:
+            pulumi.set(__self__, "delete_mode", delete_mode)
+        if resource_type is not None:
+            pulumi.set(__self__, "resource_type", resource_type)
+
+    @property
+    @pulumi.getter(name="deleteMode")
+    def delete_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        """
+        return pulumi.get(self, "delete_mode")
+
+    @delete_mode.setter
+    def delete_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delete_mode", value)
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        The type of resources that are created by cluster. Valid values:
+        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+
+        ```
+        ...
+        // Specify delete_options as below when deleting cluster
+        // delete SLB resources created by the Nginx Ingress Service
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLB"
+        }
+        // delete ALB resources created by the ALB Ingress Controller
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "ALB"
+        }
+        // delete SLS Project used by the cluster logging feature
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_Data"
+        }
+        // delete SLS Project used for the managed cluster control plane logs
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_ControlPlane"
+        }
+        ```
+        """
+        return pulumi.get(self, "resource_type")
+
+    @resource_type.setter
+    def resource_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_type", value)
+
+
+if not MYPY:
+    class ManagedKubernetesMaintenanceWindowArgsDict(TypedDict):
+        duration: NotRequired[pulumi.Input[str]]
+        """
+        The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
+        """
+        enable: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to open the maintenance window. The following parameters take effect only `enable = true`.
+        """
+        maintenance_time: NotRequired[pulumi.Input[str]]
+        """
+        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        """
+        weekly_period: NotRequired[pulumi.Input[str]]
+        """
+        Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
+
+        for example:
+        ```
+        maintenance_window {
+        enable            = true
+        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+        duration          = "3h"
+        weekly_period     = "Monday,Friday"
+        }
+        ```
+        """
+elif False:
+    ManagedKubernetesMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedKubernetesMaintenanceWindowArgs:
     def __init__(__self__, *,
-                 duration: pulumi.Input[str],
-                 enable: pulumi.Input[bool],
-                 maintenance_time: pulumi.Input[str],
-                 weekly_period: pulumi.Input[str]):
+                 duration: Optional[pulumi.Input[str]] = None,
+                 enable: Optional[pulumi.Input[bool]] = None,
+                 maintenance_time: Optional[pulumi.Input[str]] = None,
+                 weekly_period: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] duration: The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
         :param pulumi.Input[bool] enable: Whether to open the maintenance window. The following parameters take effect only `enable = true`.
-        :param pulumi.Input[str] maintenance_time: Initial maintenance time, For example:"03:00:00Z".
+        :param pulumi.Input[str] maintenance_time: Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
         :param pulumi.Input[str] weekly_period: Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
                
                for example:
-               <!--Start PulumiCodeChooser -->
-               ```python
-               import pulumi
                ```
-               <!--End PulumiCodeChooser -->
+               maintenance_window {
+               enable            = true
+               maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+               duration          = "3h"
+               weekly_period     = "Monday,Friday"
+               }
+               ```
         """
-        pulumi.set(__self__, "duration", duration)
-        pulumi.set(__self__, "enable", enable)
-        pulumi.set(__self__, "maintenance_time", maintenance_time)
-        pulumi.set(__self__, "weekly_period", weekly_period)
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+        if maintenance_time is not None:
+            pulumi.set(__self__, "maintenance_time", maintenance_time)
+        if weekly_period is not None:
+            pulumi.set(__self__, "weekly_period", weekly_period)
 
     @property
     @pulumi.getter
-    def duration(self) -> pulumi.Input[str]:
+    def duration(self) -> Optional[pulumi.Input[str]]:
         """
         The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
         """
         return pulumi.get(self, "duration")
 
     @duration.setter
-    def duration(self, value: pulumi.Input[str]):
+    def duration(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "duration", value)
 
     @property
     @pulumi.getter
-    def enable(self) -> pulumi.Input[bool]:
+    def enable(self) -> Optional[pulumi.Input[bool]]:
         """
         Whether to open the maintenance window. The following parameters take effect only `enable = true`.
         """
         return pulumi.get(self, "enable")
 
     @enable.setter
-    def enable(self, value: pulumi.Input[bool]):
+    def enable(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "enable", value)
 
     @property
     @pulumi.getter(name="maintenanceTime")
-    def maintenance_time(self) -> pulumi.Input[str]:
+    def maintenance_time(self) -> Optional[pulumi.Input[str]]:
         """
-        Initial maintenance time, For example:"03:00:00Z".
+        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
         """
         return pulumi.get(self, "maintenance_time")
 
     @maintenance_time.setter
-    def maintenance_time(self, value: pulumi.Input[str]):
+    def maintenance_time(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "maintenance_time", value)
 
     @property
     @pulumi.getter(name="weeklyPeriod")
-    def weekly_period(self) -> pulumi.Input[str]:
+    def weekly_period(self) -> Optional[pulumi.Input[str]]:
         """
         Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
 
         for example:
-        <!--Start PulumiCodeChooser -->
-        ```python
-        import pulumi
         ```
-        <!--End PulumiCodeChooser -->
+        maintenance_window {
+        enable            = true
+        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+        duration          = "3h"
+        weekly_period     = "Monday,Friday"
+        }
+        ```
         """
         return pulumi.get(self, "weekly_period")
 
     @weekly_period.setter
-    def weekly_period(self, value: pulumi.Input[str]):
+    def weekly_period(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "weekly_period", value)
 
 
+if not MYPY:
+    class ManagedKubernetesOperationPolicyArgsDict(TypedDict):
+        cluster_auto_upgrade: NotRequired[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict']]
+        """
+        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+elif False:
+    ManagedKubernetesOperationPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ManagedKubernetesOperationPolicyArgs:
+    def __init__(__self__, *,
+                 cluster_auto_upgrade: Optional[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs']] = None):
+        """
+        :param pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs'] cluster_auto_upgrade: Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+        if cluster_auto_upgrade is not None:
+            pulumi.set(__self__, "cluster_auto_upgrade", cluster_auto_upgrade)
+
+    @property
+    @pulumi.getter(name="clusterAutoUpgrade")
+    def cluster_auto_upgrade(self) -> Optional[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs']]:
+        """
+        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+        return pulumi.get(self, "cluster_auto_upgrade")
+
+    @cluster_auto_upgrade.setter
+    def cluster_auto_upgrade(self, value: Optional[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs']]):
+        pulumi.set(self, "cluster_auto_upgrade", value)
+
+
+if not MYPY:
+    class ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict(TypedDict):
+        channel: NotRequired[pulumi.Input[str]]
+        """
+        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+
+        for example:
+        ```
+        operation_policy {
+        cluster_auto_upgrade {
+        enabled = true
+        channel = "stable"
+        }
+        }
+        ```
+        """
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether the RRSA feature has been enabled.
+        """
+elif False:
+    ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs:
+    def __init__(__self__, *,
+                 channel: Optional[pulumi.Input[str]] = None,
+                 enabled: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[str] channel: The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+               
+               for example:
+               ```
+               operation_policy {
+               cluster_auto_upgrade {
+               enabled = true
+               channel = "stable"
+               }
+               }
+               ```
+        :param pulumi.Input[bool] enabled: Whether the RRSA feature has been enabled.
+        """
+        if channel is not None:
+            pulumi.set(__self__, "channel", channel)
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def channel(self) -> Optional[pulumi.Input[str]]:
+        """
+        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+
+        for example:
+        ```
+        operation_policy {
+        cluster_auto_upgrade {
+        enabled = true
+        channel = "stable"
+        }
+        }
+        ```
+        """
+        return pulumi.get(self, "channel")
+
+    @channel.setter
+    def channel(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "channel", value)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether the RRSA feature has been enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enabled", value)
+
+
+if not MYPY:
+    class ManagedKubernetesRrsaMetadataArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether the RRSA feature has been enabled.
+        """
+        ram_oidc_provider_arn: NotRequired[pulumi.Input[str]]
+        """
+        The arn of OIDC provider that was registered in RAM.
+        """
+        ram_oidc_provider_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of OIDC Provider that was registered in RAM.
+        """
+        rrsa_oidc_issuer_url: NotRequired[pulumi.Input[str]]
+        """
+        The issuer URL of RRSA OIDC Token.
+        """
+elif False:
+    ManagedKubernetesRrsaMetadataArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ManagedKubernetesRrsaMetadataArgs:
     def __init__(__self__, *,
@@ -1451,48 +2474,141 @@ class ManagedKubernetesRrsaMetadataArgs:
         pulumi.set(self, "rrsa_oidc_issuer_url", value)
 
 
+if not MYPY:
+    class NodePoolDataDiskArgsDict(TypedDict):
+        auto_format: NotRequired[pulumi.Input[str]]
+        """
+        Whether to automatically mount the data disk. Valid values: true and false.
+        """
+        auto_snapshot_policy_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the automatic snapshot policy that you want to apply to the system disk.
+        """
+        bursting_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether the data disk is enabled with Burst (performance Burst). This is configured when the disk type is cloud_auto.
+        """
+        category: NotRequired[pulumi.Input[str]]
+        """
+        The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd`, `cloud_essd`, `cloud_auto`.
+        """
+        device: NotRequired[pulumi.Input[str]]
+        """
+        The mount target of data disk N. Valid values of N: 1 to 16. If you do not specify this parameter, the system automatically assigns a mount target when Auto Scaling creates ECS instances. The name of the mount target ranges from /dev/xvdb to /dev/xvdz.
+        """
+        encrypted: NotRequired[pulumi.Input[str]]
+        """
+        Specifies whether to encrypt data disks. Valid values: true and false. Default to `false`.
+        """
+        file_system: NotRequired[pulumi.Input[str]]
+        """
+        The Mount path. Works when auto_format is true.
+        """
+        kms_key_id: NotRequired[pulumi.Input[str]]
+        """
+        The kms key id used to encrypt the data disk. It takes effect when `encrypted` is true.
+        """
+        mount_target: NotRequired[pulumi.Input[str]]
+        """
+        The type of the mounted file system. Works when auto_format is true. Optional value: `ext4`, `xfs`.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        The length is 2~128 English or Chinese characters. It must start with an uppercase or lowr letter or a Chinese character and cannot start with http:// or https. Can contain numbers, colons (:), underscores (_), or dashes (-). It will be overwritten if auto_format is set.
+        """
+        performance_level: NotRequired[pulumi.Input[str]]
+        """
+        Worker node data disk performance level, when `category` values `cloud_essd`, the optional values are `PL0`, `PL1`, `PL2` or `PL3`, but the specific performance level is related to the disk capacity. For more information, see [Enhanced SSDs](https://www.alibabacloud.com/help/doc-detail/122389.htm). Default is `PL1`.
+        """
+        provisioned_iops: NotRequired[pulumi.Input[int]]
+        """
+        The read/write IOPS preconfigured for the data disk, which is configured when the disk type is cloud_auto.
+        """
+        size: NotRequired[pulumi.Input[int]]
+        """
+        The size of a data disk, Its valid value range [40~32768] in GB. Default to `40`.
+        """
+        snapshot_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the snapshot that you want to use to create data disk N. Valid values of N: 1 to 16. If you specify this parameter, DataDisk.N.Size is ignored. The size of the disk is the same as the size of the specified snapshot. If you specify a snapshot that is created on or before July 15, 2013, the operation fails and InvalidSnapshot.TooOld is returned.
+        """
+elif False:
+    NodePoolDataDiskArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class NodePoolDataDiskArgs:
     def __init__(__self__, *,
+                 auto_format: Optional[pulumi.Input[str]] = None,
                  auto_snapshot_policy_id: Optional[pulumi.Input[str]] = None,
+                 bursting_enabled: Optional[pulumi.Input[bool]] = None,
                  category: Optional[pulumi.Input[str]] = None,
                  device: Optional[pulumi.Input[str]] = None,
                  encrypted: Optional[pulumi.Input[str]] = None,
+                 file_system: Optional[pulumi.Input[str]] = None,
                  kms_key_id: Optional[pulumi.Input[str]] = None,
+                 mount_target: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  performance_level: Optional[pulumi.Input[str]] = None,
+                 provisioned_iops: Optional[pulumi.Input[int]] = None,
                  size: Optional[pulumi.Input[int]] = None,
                  snapshot_id: Optional[pulumi.Input[str]] = None):
         """
+        :param pulumi.Input[str] auto_format: Whether to automatically mount the data disk. Valid values: true and false.
         :param pulumi.Input[str] auto_snapshot_policy_id: The ID of the automatic snapshot policy that you want to apply to the system disk.
-        :param pulumi.Input[str] category: The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd` and `cloud_essd`.
+        :param pulumi.Input[bool] bursting_enabled: Whether the data disk is enabled with Burst (performance Burst). This is configured when the disk type is cloud_auto.
+        :param pulumi.Input[str] category: The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd`, `cloud_essd`, `cloud_auto`.
         :param pulumi.Input[str] device: The mount target of data disk N. Valid values of N: 1 to 16. If you do not specify this parameter, the system automatically assigns a mount target when Auto Scaling creates ECS instances. The name of the mount target ranges from /dev/xvdb to /dev/xvdz.
         :param pulumi.Input[str] encrypted: Specifies whether to encrypt data disks. Valid values: true and false. Default to `false`.
+        :param pulumi.Input[str] file_system: The Mount path. Works when auto_format is true.
         :param pulumi.Input[str] kms_key_id: The kms key id used to encrypt the data disk. It takes effect when `encrypted` is true.
-        :param pulumi.Input[str] name: The name of data disk N. Valid values of N: 1 to 16. The name must be 2 to 128 characters in length, and can contain letters, digits, colons (:), underscores (_), and hyphens (-). The name must start with a letter but cannot start with http:// or https://.
+        :param pulumi.Input[str] mount_target: The type of the mounted file system. Works when auto_format is true. Optional value: `ext4`, `xfs`.
+        :param pulumi.Input[str] name: The length is 2~128 English or Chinese characters. It must start with an uppercase or lowr letter or a Chinese character and cannot start with http:// or https. Can contain numbers, colons (:), underscores (_), or dashes (-). It will be overwritten if auto_format is set.
         :param pulumi.Input[str] performance_level: Worker node data disk performance level, when `category` values `cloud_essd`, the optional values are `PL0`, `PL1`, `PL2` or `PL3`, but the specific performance level is related to the disk capacity. For more information, see [Enhanced SSDs](https://www.alibabacloud.com/help/doc-detail/122389.htm). Default is `PL1`.
+        :param pulumi.Input[int] provisioned_iops: The read/write IOPS preconfigured for the data disk, which is configured when the disk type is cloud_auto.
         :param pulumi.Input[int] size: The size of a data disk, Its valid value range [40~32768] in GB. Default to `40`.
         :param pulumi.Input[str] snapshot_id: The ID of the snapshot that you want to use to create data disk N. Valid values of N: 1 to 16. If you specify this parameter, DataDisk.N.Size is ignored. The size of the disk is the same as the size of the specified snapshot. If you specify a snapshot that is created on or before July 15, 2013, the operation fails and InvalidSnapshot.TooOld is returned.
         """
+        if auto_format is not None:
+            pulumi.set(__self__, "auto_format", auto_format)
         if auto_snapshot_policy_id is not None:
             pulumi.set(__self__, "auto_snapshot_policy_id", auto_snapshot_policy_id)
+        if bursting_enabled is not None:
+            pulumi.set(__self__, "bursting_enabled", bursting_enabled)
         if category is not None:
             pulumi.set(__self__, "category", category)
         if device is not None:
             pulumi.set(__self__, "device", device)
         if encrypted is not None:
             pulumi.set(__self__, "encrypted", encrypted)
+        if file_system is not None:
+            pulumi.set(__self__, "file_system", file_system)
         if kms_key_id is not None:
             pulumi.set(__self__, "kms_key_id", kms_key_id)
+        if mount_target is not None:
+            pulumi.set(__self__, "mount_target", mount_target)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if performance_level is not None:
             pulumi.set(__self__, "performance_level", performance_level)
+        if provisioned_iops is not None:
+            pulumi.set(__self__, "provisioned_iops", provisioned_iops)
         if size is not None:
             pulumi.set(__self__, "size", size)
         if snapshot_id is not None:
             pulumi.set(__self__, "snapshot_id", snapshot_id)
 
+    @property
+    @pulumi.getter(name="autoFormat")
+    def auto_format(self) -> Optional[pulumi.Input[str]]:
+        """
+        Whether to automatically mount the data disk. Valid values: true and false.
+        """
+        return pulumi.get(self, "auto_format")
+
+    @auto_format.setter
+    def auto_format(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "auto_format", value)
+
     @property
     @pulumi.getter(name="autoSnapshotPolicyId")
     def auto_snapshot_policy_id(self) -> Optional[pulumi.Input[str]]:
@@ -1505,11 +2621,23 @@ class NodePoolDataDiskArgs:
     def auto_snapshot_policy_id(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "auto_snapshot_policy_id", value)
 
+    @property
+    @pulumi.getter(name="burstingEnabled")
+    def bursting_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether the data disk is enabled with Burst (performance Burst). This is configured when the disk type is cloud_auto.
+        """
+        return pulumi.get(self, "bursting_enabled")
+
+    @bursting_enabled.setter
+    def bursting_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "bursting_enabled", value)
+
     @property
     @pulumi.getter
     def category(self) -> Optional[pulumi.Input[str]]:
         """
-        The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd` and `cloud_essd`.
+        The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd`, `cloud_essd`, `cloud_auto`.
         """
         return pulumi.get(self, "category")
 
@@ -1541,6 +2669,18 @@ class NodePoolDataDiskArgs:
     def encrypted(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "encrypted", value)
 
+    @property
+    @pulumi.getter(name="fileSystem")
+    def file_system(self) -> Optional[pulumi.Input[str]]:
+        """
+        The Mount path. Works when auto_format is true.
+        """
+        return pulumi.get(self, "file_system")
+
+    @file_system.setter
+    def file_system(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "file_system", value)
+
     @property
     @pulumi.getter(name="kmsKeyId")
     def kms_key_id(self) -> Optional[pulumi.Input[str]]:
@@ -1553,11 +2693,23 @@ class NodePoolDataDiskArgs:
     def kms_key_id(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "kms_key_id", value)
 
+    @property
+    @pulumi.getter(name="mountTarget")
+    def mount_target(self) -> Optional[pulumi.Input[str]]:
+        """
+        The type of the mounted file system. Works when auto_format is true. Optional value: `ext4`, `xfs`.
+        """
+        return pulumi.get(self, "mount_target")
+
+    @mount_target.setter
+    def mount_target(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "mount_target", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
         """
-        The name of data disk N. Valid values of N: 1 to 16. The name must be 2 to 128 characters in length, and can contain letters, digits, colons (:), underscores (_), and hyphens (-). The name must start with a letter but cannot start with http:// or https://.
+        The length is 2~128 English or Chinese characters. It must start with an uppercase or lowr letter or a Chinese character and cannot start with http:// or https. Can contain numbers, colons (:), underscores (_), or dashes (-). It will be overwritten if auto_format is set.
         """
         return pulumi.get(self, "name")
 
@@ -1577,6 +2729,18 @@ class NodePoolDataDiskArgs:
     def performance_level(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "performance_level", value)
 
+    @property
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> Optional[pulumi.Input[int]]:
+        """
+        The read/write IOPS preconfigured for the data disk, which is configured when the disk type is cloud_auto.
+        """
+        return pulumi.get(self, "provisioned_iops")
+
+    @provisioned_iops.setter
+    def provisioned_iops(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "provisioned_iops", value)
+
     @property
     @pulumi.getter
     def size(self) -> Optional[pulumi.Input[int]]:
@@ -1602,37 +2766,136 @@ class NodePoolDataDiskArgs:
         pulumi.set(self, "snapshot_id", value)
 
 
-@pulumi.input_type
-class NodePoolKubeletConfigurationArgs:
-    def __init__(__self__, *,
-                 cpu_manager_policy: Optional[pulumi.Input[str]] = None,
-                 event_burst: Optional[pulumi.Input[str]] = None,
-                 event_record_qps: Optional[pulumi.Input[str]] = None,
-                 eviction_hard: Optional[pulumi.Input[Mapping[str, Any]]] = None,
-                 eviction_soft: Optional[pulumi.Input[Mapping[str, Any]]] = None,
-                 eviction_soft_grace_period: Optional[pulumi.Input[Mapping[str, Any]]] = None,
-                 kube_api_burst: Optional[pulumi.Input[str]] = None,
-                 kube_api_qps: Optional[pulumi.Input[str]] = None,
-                 kube_reserved: Optional[pulumi.Input[Mapping[str, Any]]] = None,
-                 registry_burst: Optional[pulumi.Input[str]] = None,
-                 registry_pull_qps: Optional[pulumi.Input[str]] = None,
-                 serialize_image_pulls: Optional[pulumi.Input[str]] = None,
-                 system_reserved: Optional[pulumi.Input[Mapping[str, Any]]] = None):
+if not MYPY:
+    class NodePoolKubeletConfigurationArgsDict(TypedDict):
+        allowed_unsafe_sysctls: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
         """
-        :param pulumi.Input[str] cpu_manager_policy: Same as cpuManagerPolicy. The name of the policy to use. Requires the CPUManager feature gate to be enabled. Valid value is `none` or `static`.
-        :param pulumi.Input[str] event_burst: Same as eventBurst. The maximum size of a burst of event creations, temporarily allows event creations to burst to this number, while still not exceeding `event_record_qps`. It is only used when `event_record_qps` is greater than 0. Valid value is `[0-100]`.
-        :param pulumi.Input[str] event_record_qps: Same as eventRecordQPS. The maximum event creations per second. If 0, there is no limit enforced. Valid value is `[0-50]`.
-        :param pulumi.Input[Mapping[str, Any]] eviction_hard: Same as evictionHard. The map of signal names to quantities that defines hard eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
-        :param pulumi.Input[Mapping[str, Any]] eviction_soft: Same as evictionSoft. The map of signal names to quantities that defines soft eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
-        :param pulumi.Input[Mapping[str, Any]] eviction_soft_grace_period: Same as evictionSoftGracePeriod. The map of signal names to quantities that defines grace periods for each soft eviction signal. For example: `{"memory.available" = "30s"}`.
-        :param pulumi.Input[str] kube_api_burst: Same as kubeAPIBurst. The burst to allow while talking with kubernetes api-server. Valid value is `[0-100]`.
-        :param pulumi.Input[str] kube_api_qps: Same as kubeAPIQPS. The QPS to use while talking with kubernetes api-server. Valid value is `[0-50]`.
-        :param pulumi.Input[Mapping[str, Any]] kube_reserved: Same as kubeReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for kubernetes system components. Currently, cpu, memory and local storage for root file system are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
-        :param pulumi.Input[str] registry_burst: Same as registryBurst. The maximum size of burst pulls, temporarily allows pulls to burst to this number, while still not exceeding `registry_pull_qps`. Only used if `registry_pull_qps` is greater than 0. Valid value is `[0-100]`.
+        Allowed sysctl mode whitelist.
+        """
+        container_log_max_files: NotRequired[pulumi.Input[str]]
+        """
+        The maximum number of log files that can exist in each container.
+        """
+        container_log_max_size: NotRequired[pulumi.Input[str]]
+        """
+        The maximum size that can be reached before a log file is rotated.
+        """
+        cpu_manager_policy: NotRequired[pulumi.Input[str]]
+        """
+        Same as cpuManagerPolicy. The name of the policy to use. Requires the CPUManager feature gate to be enabled. Valid value is `none` or `static`.
+        """
+        event_burst: NotRequired[pulumi.Input[str]]
+        """
+        Same as eventBurst. The maximum size of a burst of event creations, temporarily allows event creations to burst to this number, while still not exceeding `event_record_qps`. It is only used when `event_record_qps` is greater than 0. Valid value is `[0-100]`.
+        """
+        event_record_qps: NotRequired[pulumi.Input[str]]
+        """
+        Same as eventRecordQPS. The maximum event creations per second. If 0, there is no limit enforced. Valid value is `[0-50]`.
+        """
+        eviction_hard: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Same as evictionHard. The map of signal names to quantities that defines hard eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
+        """
+        eviction_soft: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Same as evictionSoft. The map of signal names to quantities that defines soft eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
+        """
+        eviction_soft_grace_period: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Same as evictionSoftGracePeriod. The map of signal names to quantities that defines grace periods for each soft eviction signal. For example: `{"memory.available" = "30s"}`.
+        """
+        feature_gates: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[bool]]]]
+        """
+        Feature switch to enable configuration of experimental features.
+        """
+        kube_api_burst: NotRequired[pulumi.Input[str]]
+        """
+        Same as kubeAPIBurst. The burst to allow while talking with kubernetes api-server. Valid value is `[0-100]`.
+        """
+        kube_api_qps: NotRequired[pulumi.Input[str]]
+        """
+        Same as kubeAPIQPS. The QPS to use while talking with kubernetes api-server. Valid value is `[0-50]`.
+        """
+        kube_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Same as kubeReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for kubernetes system components. Currently, cpu, memory and local storage for root file system are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
+        """
+        max_pods: NotRequired[pulumi.Input[str]]
+        """
+        The maximum number of running pods.
+        """
+        read_only_port: NotRequired[pulumi.Input[str]]
+        """
+        Read-only port number.
+        """
+        registry_burst: NotRequired[pulumi.Input[str]]
+        """
+        Same as registryBurst. The maximum size of burst pulls, temporarily allows pulls to burst to this number, while still not exceeding `registry_pull_qps`. Only used if `registry_pull_qps` is greater than 0. Valid value is `[0-100]`.
+        """
+        registry_pull_qps: NotRequired[pulumi.Input[str]]
+        """
+        Same as registryPullQPS. The limit of registry pulls per second. Setting it to `0` means no limit. Valid value is `[0-50]`.
+        """
+        serialize_image_pulls: NotRequired[pulumi.Input[str]]
+        """
+        Same as serializeImagePulls. When enabled, it tells the Kubelet to pull images one at a time. We recommend not changing the default value on nodes that run docker daemon with version < 1.9 or an Aufs storage backend. Valid value is `true` or `false`.
+        """
+        system_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Same as systemReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for non-kubernetes components. Currently, only cpu and memory are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
+        """
+elif False:
+    NodePoolKubeletConfigurationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NodePoolKubeletConfigurationArgs:
+    def __init__(__self__, *,
+                 allowed_unsafe_sysctls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 container_log_max_files: Optional[pulumi.Input[str]] = None,
+                 container_log_max_size: Optional[pulumi.Input[str]] = None,
+                 cpu_manager_policy: Optional[pulumi.Input[str]] = None,
+                 event_burst: Optional[pulumi.Input[str]] = None,
+                 event_record_qps: Optional[pulumi.Input[str]] = None,
+                 eviction_hard: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 eviction_soft: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 eviction_soft_grace_period: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 feature_gates: Optional[pulumi.Input[Mapping[str, pulumi.Input[bool]]]] = None,
+                 kube_api_burst: Optional[pulumi.Input[str]] = None,
+                 kube_api_qps: Optional[pulumi.Input[str]] = None,
+                 kube_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 max_pods: Optional[pulumi.Input[str]] = None,
+                 read_only_port: Optional[pulumi.Input[str]] = None,
+                 registry_burst: Optional[pulumi.Input[str]] = None,
+                 registry_pull_qps: Optional[pulumi.Input[str]] = None,
+                 serialize_image_pulls: Optional[pulumi.Input[str]] = None,
+                 system_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_unsafe_sysctls: Allowed sysctl mode whitelist.
+        :param pulumi.Input[str] container_log_max_files: The maximum number of log files that can exist in each container.
+        :param pulumi.Input[str] container_log_max_size: The maximum size that can be reached before a log file is rotated.
+        :param pulumi.Input[str] cpu_manager_policy: Same as cpuManagerPolicy. The name of the policy to use. Requires the CPUManager feature gate to be enabled. Valid value is `none` or `static`.
+        :param pulumi.Input[str] event_burst: Same as eventBurst. The maximum size of a burst of event creations, temporarily allows event creations to burst to this number, while still not exceeding `event_record_qps`. It is only used when `event_record_qps` is greater than 0. Valid value is `[0-100]`.
+        :param pulumi.Input[str] event_record_qps: Same as eventRecordQPS. The maximum event creations per second. If 0, there is no limit enforced. Valid value is `[0-50]`.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] eviction_hard: Same as evictionHard. The map of signal names to quantities that defines hard eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] eviction_soft: Same as evictionSoft. The map of signal names to quantities that defines soft eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] eviction_soft_grace_period: Same as evictionSoftGracePeriod. The map of signal names to quantities that defines grace periods for each soft eviction signal. For example: `{"memory.available" = "30s"}`.
+        :param pulumi.Input[Mapping[str, pulumi.Input[bool]]] feature_gates: Feature switch to enable configuration of experimental features.
+        :param pulumi.Input[str] kube_api_burst: Same as kubeAPIBurst. The burst to allow while talking with kubernetes api-server. Valid value is `[0-100]`.
+        :param pulumi.Input[str] kube_api_qps: Same as kubeAPIQPS. The QPS to use while talking with kubernetes api-server. Valid value is `[0-50]`.
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] kube_reserved: Same as kubeReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for kubernetes system components. Currently, cpu, memory and local storage for root file system are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
+        :param pulumi.Input[str] max_pods: The maximum number of running pods.
+        :param pulumi.Input[str] read_only_port: Read-only port number.
+        :param pulumi.Input[str] registry_burst: Same as registryBurst. The maximum size of burst pulls, temporarily allows pulls to burst to this number, while still not exceeding `registry_pull_qps`. Only used if `registry_pull_qps` is greater than 0. Valid value is `[0-100]`.
         :param pulumi.Input[str] registry_pull_qps: Same as registryPullQPS. The limit of registry pulls per second. Setting it to `0` means no limit. Valid value is `[0-50]`.
         :param pulumi.Input[str] serialize_image_pulls: Same as serializeImagePulls. When enabled, it tells the Kubelet to pull images one at a time. We recommend not changing the default value on nodes that run docker daemon with version < 1.9 or an Aufs storage backend. Valid value is `true` or `false`.
-        :param pulumi.Input[Mapping[str, Any]] system_reserved: Same as systemReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for non-kubernetes components. Currently, only cpu and memory are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
-        """
+        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] system_reserved: Same as systemReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for non-kubernetes components. Currently, only cpu and memory are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
+        """
+        if allowed_unsafe_sysctls is not None:
+            pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
+        if container_log_max_files is not None:
+            pulumi.set(__self__, "container_log_max_files", container_log_max_files)
+        if container_log_max_size is not None:
+            pulumi.set(__self__, "container_log_max_size", container_log_max_size)
         if cpu_manager_policy is not None:
             pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
         if event_burst is not None:
@@ -1645,12 +2908,18 @@ class NodePoolKubeletConfigurationArgs:
             pulumi.set(__self__, "eviction_soft", eviction_soft)
         if eviction_soft_grace_period is not None:
             pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period)
+        if feature_gates is not None:
+            pulumi.set(__self__, "feature_gates", feature_gates)
         if kube_api_burst is not None:
             pulumi.set(__self__, "kube_api_burst", kube_api_burst)
         if kube_api_qps is not None:
             pulumi.set(__self__, "kube_api_qps", kube_api_qps)
         if kube_reserved is not None:
             pulumi.set(__self__, "kube_reserved", kube_reserved)
+        if max_pods is not None:
+            pulumi.set(__self__, "max_pods", max_pods)
+        if read_only_port is not None:
+            pulumi.set(__self__, "read_only_port", read_only_port)
         if registry_burst is not None:
             pulumi.set(__self__, "registry_burst", registry_burst)
         if registry_pull_qps is not None:
@@ -1660,6 +2929,42 @@ class NodePoolKubeletConfigurationArgs:
         if system_reserved is not None:
             pulumi.set(__self__, "system_reserved", system_reserved)
 
+    @property
+    @pulumi.getter(name="allowedUnsafeSysctls")
+    def allowed_unsafe_sysctls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Allowed sysctl mode whitelist.
+        """
+        return pulumi.get(self, "allowed_unsafe_sysctls")
+
+    @allowed_unsafe_sysctls.setter
+    def allowed_unsafe_sysctls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "allowed_unsafe_sysctls", value)
+
+    @property
+    @pulumi.getter(name="containerLogMaxFiles")
+    def container_log_max_files(self) -> Optional[pulumi.Input[str]]:
+        """
+        The maximum number of log files that can exist in each container.
+        """
+        return pulumi.get(self, "container_log_max_files")
+
+    @container_log_max_files.setter
+    def container_log_max_files(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "container_log_max_files", value)
+
+    @property
+    @pulumi.getter(name="containerLogMaxSize")
+    def container_log_max_size(self) -> Optional[pulumi.Input[str]]:
+        """
+        The maximum size that can be reached before a log file is rotated.
+        """
+        return pulumi.get(self, "container_log_max_size")
+
+    @container_log_max_size.setter
+    def container_log_max_size(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "container_log_max_size", value)
+
     @property
     @pulumi.getter(name="cpuManagerPolicy")
     def cpu_manager_policy(self) -> Optional[pulumi.Input[str]]:
@@ -1698,40 +3003,52 @@ class NodePoolKubeletConfigurationArgs:
 
     @property
     @pulumi.getter(name="evictionHard")
-    def eviction_hard(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def eviction_hard(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
         Same as evictionHard. The map of signal names to quantities that defines hard eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
         """
         return pulumi.get(self, "eviction_hard")
 
     @eviction_hard.setter
-    def eviction_hard(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def eviction_hard(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "eviction_hard", value)
 
     @property
     @pulumi.getter(name="evictionSoft")
-    def eviction_soft(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def eviction_soft(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
         Same as evictionSoft. The map of signal names to quantities that defines soft eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
         """
         return pulumi.get(self, "eviction_soft")
 
     @eviction_soft.setter
-    def eviction_soft(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def eviction_soft(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "eviction_soft", value)
 
     @property
     @pulumi.getter(name="evictionSoftGracePeriod")
-    def eviction_soft_grace_period(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def eviction_soft_grace_period(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
         Same as evictionSoftGracePeriod. The map of signal names to quantities that defines grace periods for each soft eviction signal. For example: `{"memory.available" = "30s"}`.
         """
         return pulumi.get(self, "eviction_soft_grace_period")
 
     @eviction_soft_grace_period.setter
-    def eviction_soft_grace_period(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def eviction_soft_grace_period(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "eviction_soft_grace_period", value)
 
+    @property
+    @pulumi.getter(name="featureGates")
+    def feature_gates(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[bool]]]]:
+        """
+        Feature switch to enable configuration of experimental features.
+        """
+        return pulumi.get(self, "feature_gates")
+
+    @feature_gates.setter
+    def feature_gates(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[bool]]]]):
+        pulumi.set(self, "feature_gates", value)
+
     @property
     @pulumi.getter(name="kubeApiBurst")
     def kube_api_burst(self) -> Optional[pulumi.Input[str]]:
@@ -1758,16 +3075,40 @@ class NodePoolKubeletConfigurationArgs:
 
     @property
     @pulumi.getter(name="kubeReserved")
-    def kube_reserved(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def kube_reserved(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
         Same as kubeReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for kubernetes system components. Currently, cpu, memory and local storage for root file system are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
         """
         return pulumi.get(self, "kube_reserved")
 
     @kube_reserved.setter
-    def kube_reserved(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def kube_reserved(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "kube_reserved", value)
 
+    @property
+    @pulumi.getter(name="maxPods")
+    def max_pods(self) -> Optional[pulumi.Input[str]]:
+        """
+        The maximum number of running pods.
+        """
+        return pulumi.get(self, "max_pods")
+
+    @max_pods.setter
+    def max_pods(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_pods", value)
+
+    @property
+    @pulumi.getter(name="readOnlyPort")
+    def read_only_port(self) -> Optional[pulumi.Input[str]]:
+        """
+        Read-only port number.
+        """
+        return pulumi.get(self, "read_only_port")
+
+    @read_only_port.setter
+    def read_only_port(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "read_only_port", value)
+
     @property
     @pulumi.getter(name="registryBurst")
     def registry_burst(self) -> Optional[pulumi.Input[str]]:
@@ -1806,17 +3147,30 @@ class NodePoolKubeletConfigurationArgs:
 
     @property
     @pulumi.getter(name="systemReserved")
-    def system_reserved(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
+    def system_reserved(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
         Same as systemReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for non-kubernetes components. Currently, only cpu and memory are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
         """
         return pulumi.get(self, "system_reserved")
 
     @system_reserved.setter
-    def system_reserved(self, value: Optional[pulumi.Input[Mapping[str, Any]]]):
+    def system_reserved(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "system_reserved", value)
 
 
+if not MYPY:
+    class NodePoolLabelArgsDict(TypedDict):
+        key: pulumi.Input[str]
+        """
+        The label key.
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        The label value.
+        """
+elif False:
+    NodePoolLabelArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class NodePoolLabelArgs:
     def __init__(__self__, *,
@@ -1855,48 +3209,108 @@ class NodePoolLabelArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class NodePoolManagementArgsDict(TypedDict):
+        auto_repair: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to enable automatic repair. Valid values: `true`: Automatic repair. `false`: not automatically repaired.
+        """
+        auto_repair_policy: NotRequired[pulumi.Input['NodePoolManagementAutoRepairPolicyArgsDict']]
+        """
+        Automatic repair node policy. See `auto_repair_policy` below.
+        """
+        auto_upgrade: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to enable auto update. Valid values: `true`: enables auto update. `false`: disables auto update.
+        """
+        auto_upgrade_policy: NotRequired[pulumi.Input['NodePoolManagementAutoUpgradePolicyArgsDict']]
+        """
+        The auto update policy. See `auto_upgrade_policy` below.
+        """
+        auto_vul_fix: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to automatically patch CVE vulnerabilities. Valid values: `true`, `false`.
+        """
+        auto_vul_fix_policy: NotRequired[pulumi.Input['NodePoolManagementAutoVulFixPolicyArgsDict']]
+        """
+        The auto CVE patching policy. See `auto_vul_fix_policy` below.
+        """
+        enable: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to enable the managed node pool feature. Valid values: `true`: enables the managed node pool feature. `false`: disables the managed node pool feature. Other parameters in this section take effect only when you specify enable=true.
+        """
+        max_unavailable: NotRequired[pulumi.Input[int]]
+        """
+        Maximum number of unavailable nodes. Default value: 1. Value range:\\[1,1000\\].
+        """
+        surge: NotRequired[pulumi.Input[int]]
+        """
+        Number of additional nodes. You have to specify one of surge, surge_percentage.
+        """
+        surge_percentage: NotRequired[pulumi.Input[int]]
+        """
+        Proportion of additional nodes. You have to specify one of surge, surge_percentage.
+        """
+elif False:
+    NodePoolManagementArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class NodePoolManagementArgs:
     def __init__(__self__, *,
-                 max_unavailable: pulumi.Input[int],
                  auto_repair: Optional[pulumi.Input[bool]] = None,
+                 auto_repair_policy: Optional[pulumi.Input['NodePoolManagementAutoRepairPolicyArgs']] = None,
                  auto_upgrade: Optional[pulumi.Input[bool]] = None,
+                 auto_upgrade_policy: Optional[pulumi.Input['NodePoolManagementAutoUpgradePolicyArgs']] = None,
+                 auto_vul_fix: Optional[pulumi.Input[bool]] = None,
+                 auto_vul_fix_policy: Optional[pulumi.Input['NodePoolManagementAutoVulFixPolicyArgs']] = None,
+                 enable: Optional[pulumi.Input[bool]] = None,
+                 max_unavailable: Optional[pulumi.Input[int]] = None,
                  surge: Optional[pulumi.Input[int]] = None,
                  surge_percentage: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input[int] max_unavailable: Max number of unavailable nodes. Default to `1`.
-        :param pulumi.Input[bool] auto_repair: Whether automatic repair, Default to `false`.
-        :param pulumi.Input[bool] auto_upgrade: Whether auto upgrade, Default to `false`.
+        :param pulumi.Input[bool] auto_repair: Whether to enable automatic repair. Valid values: `true`: Automatic repair. `false`: not automatically repaired.
+        :param pulumi.Input['NodePoolManagementAutoRepairPolicyArgs'] auto_repair_policy: Automatic repair node policy. See `auto_repair_policy` below.
+        :param pulumi.Input[bool] auto_upgrade: Specifies whether to enable auto update. Valid values: `true`: enables auto update. `false`: disables auto update.
+        :param pulumi.Input['NodePoolManagementAutoUpgradePolicyArgs'] auto_upgrade_policy: The auto update policy. See `auto_upgrade_policy` below.
+        :param pulumi.Input[bool] auto_vul_fix: Specifies whether to automatically patch CVE vulnerabilities. Valid values: `true`, `false`.
+        :param pulumi.Input['NodePoolManagementAutoVulFixPolicyArgs'] auto_vul_fix_policy: The auto CVE patching policy. See `auto_vul_fix_policy` below.
+        :param pulumi.Input[bool] enable: Specifies whether to enable the managed node pool feature. Valid values: `true`: enables the managed node pool feature. `false`: disables the managed node pool feature. Other parameters in this section take effect only when you specify enable=true.
+        :param pulumi.Input[int] max_unavailable: Maximum number of unavailable nodes. Default value: 1. Value range:\\[1,1000\\].
         :param pulumi.Input[int] surge: Number of additional nodes. You have to specify one of surge, surge_percentage.
         :param pulumi.Input[int] surge_percentage: Proportion of additional nodes. You have to specify one of surge, surge_percentage.
         """
-        pulumi.set(__self__, "max_unavailable", max_unavailable)
         if auto_repair is not None:
             pulumi.set(__self__, "auto_repair", auto_repair)
+        if auto_repair_policy is not None:
+            pulumi.set(__self__, "auto_repair_policy", auto_repair_policy)
         if auto_upgrade is not None:
             pulumi.set(__self__, "auto_upgrade", auto_upgrade)
+        if auto_upgrade_policy is not None:
+            pulumi.set(__self__, "auto_upgrade_policy", auto_upgrade_policy)
+        if auto_vul_fix is not None:
+            pulumi.set(__self__, "auto_vul_fix", auto_vul_fix)
+        if auto_vul_fix_policy is not None:
+            pulumi.set(__self__, "auto_vul_fix_policy", auto_vul_fix_policy)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+        if max_unavailable is not None:
+            pulumi.set(__self__, "max_unavailable", max_unavailable)
+        if surge is not None:
+            warnings.warn("""Field 'surge' has been deprecated from provider version 1.219.0. Number of additional nodes. You have to specify one of surge, surge_percentage.""", DeprecationWarning)
+            pulumi.log.warn("""surge is deprecated: Field 'surge' has been deprecated from provider version 1.219.0. Number of additional nodes. You have to specify one of surge, surge_percentage.""")
         if surge is not None:
             pulumi.set(__self__, "surge", surge)
+        if surge_percentage is not None:
+            warnings.warn("""Field 'surge_percentage' has been deprecated from provider version 1.219.0. Proportion of additional nodes. You have to specify one of surge, surge_percentage.""", DeprecationWarning)
+            pulumi.log.warn("""surge_percentage is deprecated: Field 'surge_percentage' has been deprecated from provider version 1.219.0. Proportion of additional nodes. You have to specify one of surge, surge_percentage.""")
         if surge_percentage is not None:
             pulumi.set(__self__, "surge_percentage", surge_percentage)
 
-    @property
-    @pulumi.getter(name="maxUnavailable")
-    def max_unavailable(self) -> pulumi.Input[int]:
-        """
-        Max number of unavailable nodes. Default to `1`.
-        """
-        return pulumi.get(self, "max_unavailable")
-
-    @max_unavailable.setter
-    def max_unavailable(self, value: pulumi.Input[int]):
-        pulumi.set(self, "max_unavailable", value)
-
     @property
     @pulumi.getter(name="autoRepair")
     def auto_repair(self) -> Optional[pulumi.Input[bool]]:
         """
-        Whether automatic repair, Default to `false`.
+        Whether to enable automatic repair. Valid values: `true`: Automatic repair. `false`: not automatically repaired.
         """
         return pulumi.get(self, "auto_repair")
 
@@ -1904,11 +3318,23 @@ class NodePoolManagementArgs:
     def auto_repair(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "auto_repair", value)
 
+    @property
+    @pulumi.getter(name="autoRepairPolicy")
+    def auto_repair_policy(self) -> Optional[pulumi.Input['NodePoolManagementAutoRepairPolicyArgs']]:
+        """
+        Automatic repair node policy. See `auto_repair_policy` below.
+        """
+        return pulumi.get(self, "auto_repair_policy")
+
+    @auto_repair_policy.setter
+    def auto_repair_policy(self, value: Optional[pulumi.Input['NodePoolManagementAutoRepairPolicyArgs']]):
+        pulumi.set(self, "auto_repair_policy", value)
+
     @property
     @pulumi.getter(name="autoUpgrade")
     def auto_upgrade(self) -> Optional[pulumi.Input[bool]]:
         """
-        Whether auto upgrade, Default to `false`.
+        Specifies whether to enable auto update. Valid values: `true`: enables auto update. `false`: disables auto update.
         """
         return pulumi.get(self, "auto_upgrade")
 
@@ -1916,8 +3342,69 @@ class NodePoolManagementArgs:
     def auto_upgrade(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "auto_upgrade", value)
 
+    @property
+    @pulumi.getter(name="autoUpgradePolicy")
+    def auto_upgrade_policy(self) -> Optional[pulumi.Input['NodePoolManagementAutoUpgradePolicyArgs']]:
+        """
+        The auto update policy. See `auto_upgrade_policy` below.
+        """
+        return pulumi.get(self, "auto_upgrade_policy")
+
+    @auto_upgrade_policy.setter
+    def auto_upgrade_policy(self, value: Optional[pulumi.Input['NodePoolManagementAutoUpgradePolicyArgs']]):
+        pulumi.set(self, "auto_upgrade_policy", value)
+
+    @property
+    @pulumi.getter(name="autoVulFix")
+    def auto_vul_fix(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Specifies whether to automatically patch CVE vulnerabilities. Valid values: `true`, `false`.
+        """
+        return pulumi.get(self, "auto_vul_fix")
+
+    @auto_vul_fix.setter
+    def auto_vul_fix(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "auto_vul_fix", value)
+
+    @property
+    @pulumi.getter(name="autoVulFixPolicy")
+    def auto_vul_fix_policy(self) -> Optional[pulumi.Input['NodePoolManagementAutoVulFixPolicyArgs']]:
+        """
+        The auto CVE patching policy. See `auto_vul_fix_policy` below.
+        """
+        return pulumi.get(self, "auto_vul_fix_policy")
+
+    @auto_vul_fix_policy.setter
+    def auto_vul_fix_policy(self, value: Optional[pulumi.Input['NodePoolManagementAutoVulFixPolicyArgs']]):
+        pulumi.set(self, "auto_vul_fix_policy", value)
+
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Specifies whether to enable the managed node pool feature. Valid values: `true`: enables the managed node pool feature. `false`: disables the managed node pool feature. Other parameters in this section take effect only when you specify enable=true.
+        """
+        return pulumi.get(self, "enable")
+
+    @enable.setter
+    def enable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable", value)
+
+    @property
+    @pulumi.getter(name="maxUnavailable")
+    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
+        """
+        Maximum number of unavailable nodes. Default value: 1. Value range:\\[1,1000\\].
+        """
+        return pulumi.get(self, "max_unavailable")
+
+    @max_unavailable.setter
+    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_unavailable", value)
+
     @property
     @pulumi.getter
+    @_utilities.deprecated("""Field 'surge' has been deprecated from provider version 1.219.0. Number of additional nodes. You have to specify one of surge, surge_percentage.""")
     def surge(self) -> Optional[pulumi.Input[int]]:
         """
         Number of additional nodes. You have to specify one of surge, surge_percentage.
@@ -1930,6 +3417,7 @@ class NodePoolManagementArgs:
 
     @property
     @pulumi.getter(name="surgePercentage")
+    @_utilities.deprecated("""Field 'surge_percentage' has been deprecated from provider version 1.219.0. Proportion of additional nodes. You have to specify one of surge, surge_percentage.""")
     def surge_percentage(self) -> Optional[pulumi.Input[int]]:
         """
         Proportion of additional nodes. You have to specify one of surge, surge_percentage.
@@ -1941,128 +3429,309 @@ class NodePoolManagementArgs:
         pulumi.set(self, "surge_percentage", value)
 
 
+if not MYPY:
+    class NodePoolManagementAutoRepairPolicyArgsDict(TypedDict):
+        restart_node: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
+        """
+elif False:
+    NodePoolManagementAutoRepairPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
-class NodePoolRollingPolicyArgs:
+class NodePoolManagementAutoRepairPolicyArgs:
     def __init__(__self__, *,
-                 max_parallelism: Optional[pulumi.Input[int]] = None):
+                 restart_node: Optional[pulumi.Input[bool]] = None):
         """
-        :param pulumi.Input[int] max_parallelism: Maximum parallel number nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used.
+        :param pulumi.Input[bool] restart_node: Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
         """
-        if max_parallelism is not None:
-            pulumi.set(__self__, "max_parallelism", max_parallelism)
+        if restart_node is not None:
+            pulumi.set(__self__, "restart_node", restart_node)
 
     @property
-    @pulumi.getter(name="maxParallelism")
-    def max_parallelism(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="restartNode")
+    def restart_node(self) -> Optional[pulumi.Input[bool]]:
         """
-        Maximum parallel number nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used.
+        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
         """
-        return pulumi.get(self, "max_parallelism")
+        return pulumi.get(self, "restart_node")
 
-    @max_parallelism.setter
-    def max_parallelism(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "max_parallelism", value)
+    @restart_node.setter
+    def restart_node(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "restart_node", value)
 
 
+if not MYPY:
+    class NodePoolManagementAutoUpgradePolicyArgsDict(TypedDict):
+        auto_upgrade_kubelet: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether  to automatically update the kubelet. Valid values: `true`: yes; `false`: no.
+        """
+elif False:
+    NodePoolManagementAutoUpgradePolicyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
-class NodePoolRolloutPolicyArgs:
+class NodePoolManagementAutoUpgradePolicyArgs:
     def __init__(__self__, *,
-                 max_unavailable: Optional[pulumi.Input[int]] = None):
+                 auto_upgrade_kubelet: Optional[pulumi.Input[bool]] = None):
         """
-        :param pulumi.Input[int] max_unavailable: Maximum number of unavailable nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used. Please use `max_parallelism` to instead it from provider version 1.185.0.
+        :param pulumi.Input[bool] auto_upgrade_kubelet: Specifies whether  to automatically update the kubelet. Valid values: `true`: yes; `false`: no.
         """
-        if max_unavailable is not None:
-            pulumi.set(__self__, "max_unavailable", max_unavailable)
+        if auto_upgrade_kubelet is not None:
+            pulumi.set(__self__, "auto_upgrade_kubelet", auto_upgrade_kubelet)
 
     @property
-    @pulumi.getter(name="maxUnavailable")
-    def max_unavailable(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="autoUpgradeKubelet")
+    def auto_upgrade_kubelet(self) -> Optional[pulumi.Input[bool]]:
         """
-        Maximum number of unavailable nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used. Please use `max_parallelism` to instead it from provider version 1.185.0.
+        Specifies whether  to automatically update the kubelet. Valid values: `true`: yes; `false`: no.
         """
-        return pulumi.get(self, "max_unavailable")
+        return pulumi.get(self, "auto_upgrade_kubelet")
+
+    @auto_upgrade_kubelet.setter
+    def auto_upgrade_kubelet(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "auto_upgrade_kubelet", value)
 
-    @max_unavailable.setter
-    def max_unavailable(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "max_unavailable", value)
 
+if not MYPY:
+    class NodePoolManagementAutoVulFixPolicyArgsDict(TypedDict):
+        restart_node: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
+        """
+        vul_level: NotRequired[pulumi.Input[str]]
+        """
+        The severity levels of vulnerabilities that is allowed to automatically patch. Multiple severity levels are separated by commas (,).
+        """
+elif False:
+    NodePoolManagementAutoVulFixPolicyArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class NodePoolScalingConfigArgs:
+class NodePoolManagementAutoVulFixPolicyArgs:
     def __init__(__self__, *,
-                 max_size: pulumi.Input[int],
-                 min_size: pulumi.Input[int],
-                 eip_bandwidth: Optional[pulumi.Input[int]] = None,
-                 eip_internet_charge_type: Optional[pulumi.Input[str]] = None,
-                 is_bond_eip: Optional[pulumi.Input[bool]] = None,
-                 type: Optional[pulumi.Input[str]] = None):
+                 restart_node: Optional[pulumi.Input[bool]] = None,
+                 vul_level: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[int] max_size: Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
-        :param pulumi.Input[int] min_size: Min number of instances in a auto scaling group, its valid value range [0~1000].
-        :param pulumi.Input[int] eip_bandwidth: Peak EIP bandwidth. Its valid value range [1~500] in Mbps. Default to `5`.
-        :param pulumi.Input[str] eip_internet_charge_type: EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. Conflict with `internet_charge_type`, EIP and public network IP can only choose one.
-        :param pulumi.Input[bool] is_bond_eip: Whether to bind EIP for an instance. Default: `false`.
-        :param pulumi.Input[str] type: Instance classification, not required. Vaild value: `cpu`, `gpu`, `gpushare` and `spot`. Default: `cpu`. The actual instance type is determined by `instance_types`.
+        :param pulumi.Input[bool] restart_node: Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
+        :param pulumi.Input[str] vul_level: The severity levels of vulnerabilities that is allowed to automatically patch. Multiple severity levels are separated by commas (,).
         """
-        pulumi.set(__self__, "max_size", max_size)
-        pulumi.set(__self__, "min_size", min_size)
-        if eip_bandwidth is not None:
-            pulumi.set(__self__, "eip_bandwidth", eip_bandwidth)
-        if eip_internet_charge_type is not None:
-            pulumi.set(__self__, "eip_internet_charge_type", eip_internet_charge_type)
-        if is_bond_eip is not None:
-            pulumi.set(__self__, "is_bond_eip", is_bond_eip)
-        if type is not None:
-            pulumi.set(__self__, "type", type)
+        if restart_node is not None:
+            pulumi.set(__self__, "restart_node", restart_node)
+        if vul_level is not None:
+            pulumi.set(__self__, "vul_level", vul_level)
 
     @property
-    @pulumi.getter(name="maxSize")
-    def max_size(self) -> pulumi.Input[int]:
+    @pulumi.getter(name="restartNode")
+    def restart_node(self) -> Optional[pulumi.Input[bool]]:
         """
-        Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
+        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
         """
-        return pulumi.get(self, "max_size")
+        return pulumi.get(self, "restart_node")
 
-    @max_size.setter
-    def max_size(self, value: pulumi.Input[int]):
-        pulumi.set(self, "max_size", value)
+    @restart_node.setter
+    def restart_node(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "restart_node", value)
 
     @property
-    @pulumi.getter(name="minSize")
-    def min_size(self) -> pulumi.Input[int]:
+    @pulumi.getter(name="vulLevel")
+    def vul_level(self) -> Optional[pulumi.Input[str]]:
         """
-        Min number of instances in a auto scaling group, its valid value range [0~1000].
+        The severity levels of vulnerabilities that is allowed to automatically patch. Multiple severity levels are separated by commas (,).
         """
-        return pulumi.get(self, "min_size")
+        return pulumi.get(self, "vul_level")
 
-    @min_size.setter
-    def min_size(self, value: pulumi.Input[int]):
-        pulumi.set(self, "min_size", value)
+    @vul_level.setter
+    def vul_level(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "vul_level", value)
 
-    @property
-    @pulumi.getter(name="eipBandwidth")
-    def eip_bandwidth(self) -> Optional[pulumi.Input[int]]:
+
+if not MYPY:
+    class NodePoolPrivatePoolOptionsArgsDict(TypedDict):
+        private_pool_options_id: NotRequired[pulumi.Input[str]]
         """
-        Peak EIP bandwidth. Its valid value range [1~500] in Mbps. Default to `5`.
+        The ID of the private node pool.
         """
-        return pulumi.get(self, "eip_bandwidth")
+        private_pool_options_match_criteria: NotRequired[pulumi.Input[str]]
+        """
+        The type of private node pool. This parameter specifies the type of the private pool that you want to use to create instances. A private node pool is generated when an elasticity assurance or a capacity reservation service takes effect. The system selects a private node pool to launch instances. Valid values: `Open`: specifies an open private node pool. The system selects an open private node pool to launch instances. If no matching open private node pool is available, the resources in the public node pool are used. `Target`: specifies a private node pool. The system uses the resources of the specified private node pool to launch instances. If the specified private node pool is unavailable, instances cannot be started. `None`: no private node pool is used. The resources of private node pools are not used to launch the instances.
+        """
+elif False:
+    NodePoolPrivatePoolOptionsArgsDict: TypeAlias = Mapping[str, Any]
 
-    @eip_bandwidth.setter
-    def eip_bandwidth(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "eip_bandwidth", value)
+@pulumi.input_type
+class NodePoolPrivatePoolOptionsArgs:
+    def __init__(__self__, *,
+                 private_pool_options_id: Optional[pulumi.Input[str]] = None,
+                 private_pool_options_match_criteria: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] private_pool_options_id: The ID of the private node pool.
+        :param pulumi.Input[str] private_pool_options_match_criteria: The type of private node pool. This parameter specifies the type of the private pool that you want to use to create instances. A private node pool is generated when an elasticity assurance or a capacity reservation service takes effect. The system selects a private node pool to launch instances. Valid values: `Open`: specifies an open private node pool. The system selects an open private node pool to launch instances. If no matching open private node pool is available, the resources in the public node pool are used. `Target`: specifies a private node pool. The system uses the resources of the specified private node pool to launch instances. If the specified private node pool is unavailable, instances cannot be started. `None`: no private node pool is used. The resources of private node pools are not used to launch the instances.
+        """
+        if private_pool_options_id is not None:
+            pulumi.set(__self__, "private_pool_options_id", private_pool_options_id)
+        if private_pool_options_match_criteria is not None:
+            pulumi.set(__self__, "private_pool_options_match_criteria", private_pool_options_match_criteria)
 
     @property
-    @pulumi.getter(name="eipInternetChargeType")
-    def eip_internet_charge_type(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="privatePoolOptionsId")
+    def private_pool_options_id(self) -> Optional[pulumi.Input[str]]:
         """
-        EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. Conflict with `internet_charge_type`, EIP and public network IP can only choose one.
+        The ID of the private node pool.
         """
-        return pulumi.get(self, "eip_internet_charge_type")
+        return pulumi.get(self, "private_pool_options_id")
+
+    @private_pool_options_id.setter
+    def private_pool_options_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "private_pool_options_id", value)
+
+    @property
+    @pulumi.getter(name="privatePoolOptionsMatchCriteria")
+    def private_pool_options_match_criteria(self) -> Optional[pulumi.Input[str]]:
+        """
+        The type of private node pool. This parameter specifies the type of the private pool that you want to use to create instances. A private node pool is generated when an elasticity assurance or a capacity reservation service takes effect. The system selects a private node pool to launch instances. Valid values: `Open`: specifies an open private node pool. The system selects an open private node pool to launch instances. If no matching open private node pool is available, the resources in the public node pool are used. `Target`: specifies a private node pool. The system uses the resources of the specified private node pool to launch instances. If the specified private node pool is unavailable, instances cannot be started. `None`: no private node pool is used. The resources of private node pools are not used to launch the instances.
+        """
+        return pulumi.get(self, "private_pool_options_match_criteria")
+
+    @private_pool_options_match_criteria.setter
+    def private_pool_options_match_criteria(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "private_pool_options_match_criteria", value)
+
+
+if not MYPY:
+    class NodePoolRollingPolicyArgsDict(TypedDict):
+        max_parallelism: NotRequired[pulumi.Input[int]]
+        """
+        The maximum number of unusable nodes.
+        """
+elif False:
+    NodePoolRollingPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NodePoolRollingPolicyArgs:
+    def __init__(__self__, *,
+                 max_parallelism: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[int] max_parallelism: The maximum number of unusable nodes.
+        """
+        if max_parallelism is not None:
+            pulumi.set(__self__, "max_parallelism", max_parallelism)
+
+    @property
+    @pulumi.getter(name="maxParallelism")
+    def max_parallelism(self) -> Optional[pulumi.Input[int]]:
+        """
+        The maximum number of unusable nodes.
+        """
+        return pulumi.get(self, "max_parallelism")
+
+    @max_parallelism.setter
+    def max_parallelism(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_parallelism", value)
+
+
+if not MYPY:
+    class NodePoolScalingConfigArgsDict(TypedDict):
+        eip_bandwidth: NotRequired[pulumi.Input[int]]
+        """
+        Peak EIP bandwidth. Its valid value range [1~500] in Mbps. It works if `is_bond_eip=true`. Default to `5`.
+        """
+        eip_internet_charge_type: NotRequired[pulumi.Input[str]]
+        """
+        EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. It works if `is_bond_eip=true`, conflict with `internet_charge_type`. EIP and public network IP can only choose one.
+        """
+        enable: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to enable automatic scaling. Value:
+        """
+        is_bond_eip: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to bind EIP for an instance. Default: `false`.
+        """
+        max_size: NotRequired[pulumi.Input[int]]
+        """
+        Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
+        """
+        min_size: NotRequired[pulumi.Input[int]]
+        """
+        Min number of instances in a auto scaling group, its valid value range [0~1000].
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Instance classification, not required. Vaild value: `cpu`, `gpu`, `gpushare` and `spot`. Default: `cpu`. The actual instance type is determined by `instance_types`.
+        """
+elif False:
+    NodePoolScalingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NodePoolScalingConfigArgs:
+    def __init__(__self__, *,
+                 eip_bandwidth: Optional[pulumi.Input[int]] = None,
+                 eip_internet_charge_type: Optional[pulumi.Input[str]] = None,
+                 enable: Optional[pulumi.Input[bool]] = None,
+                 is_bond_eip: Optional[pulumi.Input[bool]] = None,
+                 max_size: Optional[pulumi.Input[int]] = None,
+                 min_size: Optional[pulumi.Input[int]] = None,
+                 type: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[int] eip_bandwidth: Peak EIP bandwidth. Its valid value range [1~500] in Mbps. It works if `is_bond_eip=true`. Default to `5`.
+        :param pulumi.Input[str] eip_internet_charge_type: EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. It works if `is_bond_eip=true`, conflict with `internet_charge_type`. EIP and public network IP can only choose one.
+        :param pulumi.Input[bool] enable: Whether to enable automatic scaling. Value:
+        :param pulumi.Input[bool] is_bond_eip: Whether to bind EIP for an instance. Default: `false`.
+        :param pulumi.Input[int] max_size: Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
+        :param pulumi.Input[int] min_size: Min number of instances in a auto scaling group, its valid value range [0~1000].
+        :param pulumi.Input[str] type: Instance classification, not required. Vaild value: `cpu`, `gpu`, `gpushare` and `spot`. Default: `cpu`. The actual instance type is determined by `instance_types`.
+        """
+        if eip_bandwidth is not None:
+            pulumi.set(__self__, "eip_bandwidth", eip_bandwidth)
+        if eip_internet_charge_type is not None:
+            pulumi.set(__self__, "eip_internet_charge_type", eip_internet_charge_type)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+        if is_bond_eip is not None:
+            pulumi.set(__self__, "is_bond_eip", is_bond_eip)
+        if max_size is not None:
+            pulumi.set(__self__, "max_size", max_size)
+        if min_size is not None:
+            pulumi.set(__self__, "min_size", min_size)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="eipBandwidth")
+    def eip_bandwidth(self) -> Optional[pulumi.Input[int]]:
+        """
+        Peak EIP bandwidth. Its valid value range [1~500] in Mbps. It works if `is_bond_eip=true`. Default to `5`.
+        """
+        return pulumi.get(self, "eip_bandwidth")
+
+    @eip_bandwidth.setter
+    def eip_bandwidth(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "eip_bandwidth", value)
+
+    @property
+    @pulumi.getter(name="eipInternetChargeType")
+    def eip_internet_charge_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. It works if `is_bond_eip=true`, conflict with `internet_charge_type`. EIP and public network IP can only choose one.
+        """
+        return pulumi.get(self, "eip_internet_charge_type")
 
     @eip_internet_charge_type.setter
     def eip_internet_charge_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "eip_internet_charge_type", value)
 
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to enable automatic scaling. Value:
+        """
+        return pulumi.get(self, "enable")
+
+    @enable.setter
+    def enable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable", value)
+
     @property
     @pulumi.getter(name="isBondEip")
     def is_bond_eip(self) -> Optional[pulumi.Input[bool]]:
@@ -2075,6 +3744,30 @@ class NodePoolScalingConfigArgs:
     def is_bond_eip(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "is_bond_eip", value)
 
+    @property
+    @pulumi.getter(name="maxSize")
+    def max_size(self) -> Optional[pulumi.Input[int]]:
+        """
+        Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
+        """
+        return pulumi.get(self, "max_size")
+
+    @max_size.setter
+    def max_size(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_size", value)
+
+    @property
+    @pulumi.getter(name="minSize")
+    def min_size(self) -> Optional[pulumi.Input[int]]:
+        """
+        Min number of instances in a auto scaling group, its valid value range [0~1000].
+        """
+        return pulumi.get(self, "min_size")
+
+    @min_size.setter
+    def min_size(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "min_size", value)
+
     @property
     @pulumi.getter
     def type(self) -> Optional[pulumi.Input[str]]:
@@ -2088,14 +3781,27 @@ class NodePoolScalingConfigArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class NodePoolSpotPriceLimitArgsDict(TypedDict):
+        instance_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of the preemptible instance.
+        """
+        price_limit: NotRequired[pulumi.Input[str]]
+        """
+        The maximum price of a single instance.
+        """
+elif False:
+    NodePoolSpotPriceLimitArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class NodePoolSpotPriceLimitArgs:
     def __init__(__self__, *,
                  instance_type: Optional[pulumi.Input[str]] = None,
                  price_limit: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] instance_type: Spot instance type.
-        :param pulumi.Input[str] price_limit: The maximum hourly price of the spot instance. A maximum of three decimal places are allowed.
+        :param pulumi.Input[str] instance_type: The type of the preemptible instance.
+        :param pulumi.Input[str] price_limit: The maximum price of a single instance.
         """
         if instance_type is not None:
             pulumi.set(__self__, "instance_type", instance_type)
@@ -2106,7 +3812,7 @@ class NodePoolSpotPriceLimitArgs:
     @pulumi.getter(name="instanceType")
     def instance_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Spot instance type.
+        The type of the preemptible instance.
         """
         return pulumi.get(self, "instance_type")
 
@@ -2118,7 +3824,7 @@ class NodePoolSpotPriceLimitArgs:
     @pulumi.getter(name="priceLimit")
     def price_limit(self) -> Optional[pulumi.Input[str]]:
         """
-        The maximum hourly price of the spot instance. A maximum of three decimal places are allowed.
+        The maximum price of a single instance.
         """
         return pulumi.get(self, "price_limit")
 
@@ -2127,6 +3833,23 @@ class NodePoolSpotPriceLimitArgs:
         pulumi.set(self, "price_limit", value)
 
 
+if not MYPY:
+    class NodePoolTaintArgsDict(TypedDict):
+        key: pulumi.Input[str]
+        """
+        The key of a taint.
+        """
+        effect: NotRequired[pulumi.Input[str]]
+        """
+        The scheduling policy.
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        The value of a taint.
+        """
+elif False:
+    NodePoolTaintArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class NodePoolTaintArgs:
     def __init__(__self__, *,
@@ -2181,18 +3904,129 @@ class NodePoolTaintArgs:
         pulumi.set(self, "value", value)
 
 
+if not MYPY:
+    class NodePoolTeeConfigArgsDict(TypedDict):
+        tee_enable: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether to enable confidential computing for the cluster.
+        """
+elif False:
+    NodePoolTeeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NodePoolTeeConfigArgs:
+    def __init__(__self__, *,
+                 tee_enable: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[bool] tee_enable: Specifies whether to enable confidential computing for the cluster.
+        """
+        if tee_enable is not None:
+            pulumi.set(__self__, "tee_enable", tee_enable)
+
+    @property
+    @pulumi.getter(name="teeEnable")
+    def tee_enable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Specifies whether to enable confidential computing for the cluster.
+        """
+        return pulumi.get(self, "tee_enable")
+
+    @tee_enable.setter
+    def tee_enable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "tee_enable", value)
+
+
+if not MYPY:
+    class ServerlessKubernetesAddonArgsDict(TypedDict):
+        config: NotRequired[pulumi.Input[str]]
+        """
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
+        """
+        disabled: NotRequired[pulumi.Input[bool]]
+        """
+        Disables the automatic installation of a component. Default is `false`.
+
+        The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with ALB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        # install ALB ingress, conflict with nginx ingress
+        addons {
+        name = "alb-ingress-controller"
+        }
+        # install metric server
+        addons {
+        name = "metrics-server"
+        }
+        # install knative
+        addons {
+        name = "knative"
+        }
+        # install prometheus
+        addons {
+        name = "arms-prometheus"
+        }
+        ```
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        It specifies the version of the component.
+        """
+elif False:
+    ServerlessKubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ServerlessKubernetesAddonArgs:
     def __init__(__self__, *,
                  config: Optional[pulumi.Input[str]] = None,
                  disabled: Optional[pulumi.Input[bool]] = None,
-                 name: Optional[pulumi.Input[str]] = None):
+                 name: Optional[pulumi.Input[str]] = None,
+                 version: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] config: The ACK add-on configurations.
+        :param pulumi.Input[str] config: The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         :param pulumi.Input[bool] disabled: Disables the automatic installation of a component. Default is `false`.
                
                The following example is the definition of addons block, The type of this field is list:
+               
+               ```
+               # install nginx ingress, conflict with ALB ingress
+               addons {
+               name = "nginx-ingress-controller"
+               # use internet
+               config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               # if use intranet, detail below.
+               # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               }
+               # install ALB ingress, conflict with nginx ingress
+               addons {
+               name = "alb-ingress-controller"
+               }
+               # install metric server
+               addons {
+               name = "metrics-server"
+               }
+               # install knative
+               addons {
+               name = "knative"
+               }
+               # install prometheus
+               addons {
+               name = "arms-prometheus"
+               }
+               ```
         :param pulumi.Input[str] name: Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
+        :param pulumi.Input[str] version: It specifies the version of the component.
         """
         if config is not None:
             pulumi.set(__self__, "config", config)
@@ -2200,12 +4034,14 @@ class ServerlessKubernetesAddonArgs:
             pulumi.set(__self__, "disabled", disabled)
         if name is not None:
             pulumi.set(__self__, "name", name)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
 
     @property
     @pulumi.getter
     def config(self) -> Optional[pulumi.Input[str]]:
         """
-        The ACK add-on configurations.
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -2220,6 +4056,33 @@ class ServerlessKubernetesAddonArgs:
         Disables the automatic installation of a component. Default is `false`.
 
         The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with ALB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        # install ALB ingress, conflict with nginx ingress
+        addons {
+        name = "alb-ingress-controller"
+        }
+        # install metric server
+        addons {
+        name = "metrics-server"
+        }
+        # install knative
+        addons {
+        name = "knative"
+        }
+        # install prometheus
+        addons {
+        name = "arms-prometheus"
+        }
+        ```
         """
         return pulumi.get(self, "disabled")
 
@@ -2239,6 +4102,429 @@ class ServerlessKubernetesAddonArgs:
     def name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "name", value)
 
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[str]]:
+        """
+        It specifies the version of the component.
+        """
+        return pulumi.get(self, "version")
+
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "version", value)
+
+
+if not MYPY:
+    class ServerlessKubernetesDeleteOptionArgsDict(TypedDict):
+        delete_mode: NotRequired[pulumi.Input[str]]
+        """
+        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of resources that are created by cluster. Valid values:
+        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+        - `PrivateZone`: PrivateZone resources created by the cluster, default behavior is to retain, option to delete is available.
+        ```
+        ...
+        // Specify delete_options as below when deleting cluster
+        // delete SLB resources created by the Nginx Ingress Service
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLB"
+        }
+        // delete ALB resources created by the ALB Ingress Controller
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "ALB"
+        }
+        // delete SLS Project used by the cluster logging feature
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_Data"
+        }
+        // delete SLS Project used for the managed cluster control plane logs
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_ControlPlane"
+        }
+        // delete PrivateZone resources created by the cluster
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "PrivateZone"
+        }
+        ```
+        """
+elif False:
+    ServerlessKubernetesDeleteOptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServerlessKubernetesDeleteOptionArgs:
+    def __init__(__self__, *,
+                 delete_mode: Optional[pulumi.Input[str]] = None,
+                 resource_type: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] delete_mode: The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        :param pulumi.Input[str] resource_type: The type of resources that are created by cluster. Valid values:
+               - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+               - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+               - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+               - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+               - `PrivateZone`: PrivateZone resources created by the cluster, default behavior is to retain, option to delete is available.
+               ```
+               ...
+               // Specify delete_options as below when deleting cluster
+               // delete SLB resources created by the Nginx Ingress Service
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLB"
+               }
+               // delete ALB resources created by the ALB Ingress Controller
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "ALB"
+               }
+               // delete SLS Project used by the cluster logging feature
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLS_Data"
+               }
+               // delete SLS Project used for the managed cluster control plane logs
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "SLS_ControlPlane"
+               }
+               // delete PrivateZone resources created by the cluster
+               delete_options {
+               delete_mode = "delete"
+               resource_type = "PrivateZone"
+               }
+               ```
+        """
+        if delete_mode is not None:
+            pulumi.set(__self__, "delete_mode", delete_mode)
+        if resource_type is not None:
+            pulumi.set(__self__, "resource_type", resource_type)
+
+    @property
+    @pulumi.getter(name="deleteMode")
+    def delete_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        """
+        return pulumi.get(self, "delete_mode")
+
+    @delete_mode.setter
+    def delete_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delete_mode", value)
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> Optional[pulumi.Input[str]]:
+        """
+        The type of resources that are created by cluster. Valid values:
+        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
+        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
+        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
+        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
+        - `PrivateZone`: PrivateZone resources created by the cluster, default behavior is to retain, option to delete is available.
+        ```
+        ...
+        // Specify delete_options as below when deleting cluster
+        // delete SLB resources created by the Nginx Ingress Service
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLB"
+        }
+        // delete ALB resources created by the ALB Ingress Controller
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "ALB"
+        }
+        // delete SLS Project used by the cluster logging feature
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_Data"
+        }
+        // delete SLS Project used for the managed cluster control plane logs
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "SLS_ControlPlane"
+        }
+        // delete PrivateZone resources created by the cluster
+        delete_options {
+        delete_mode = "delete"
+        resource_type = "PrivateZone"
+        }
+        ```
+        """
+        return pulumi.get(self, "resource_type")
+
+    @resource_type.setter
+    def resource_type(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_type", value)
+
+
+if not MYPY:
+    class ServerlessKubernetesMaintenanceWindowArgsDict(TypedDict):
+        duration: NotRequired[pulumi.Input[str]]
+        """
+        The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
+        """
+        enable: NotRequired[pulumi.Input[bool]]
+        """
+        Whether to open the maintenance window. The following parameters take effect only `enable = true`.
+        """
+        maintenance_time: NotRequired[pulumi.Input[str]]
+        """
+        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        """
+        weekly_period: NotRequired[pulumi.Input[str]]
+        """
+        Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
+
+        for example:
+        ```
+        maintenance_window {
+        enable            = true
+        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+        duration          = "3h"
+        weekly_period     = "Monday,Friday"
+        }
+        ```
+        """
+elif False:
+    ServerlessKubernetesMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServerlessKubernetesMaintenanceWindowArgs:
+    def __init__(__self__, *,
+                 duration: Optional[pulumi.Input[str]] = None,
+                 enable: Optional[pulumi.Input[bool]] = None,
+                 maintenance_time: Optional[pulumi.Input[str]] = None,
+                 weekly_period: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] duration: The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
+        :param pulumi.Input[bool] enable: Whether to open the maintenance window. The following parameters take effect only `enable = true`.
+        :param pulumi.Input[str] maintenance_time: Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        :param pulumi.Input[str] weekly_period: Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
+               
+               for example:
+               ```
+               maintenance_window {
+               enable            = true
+               maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+               duration          = "3h"
+               weekly_period     = "Monday,Friday"
+               }
+               ```
+        """
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+        if maintenance_time is not None:
+            pulumi.set(__self__, "maintenance_time", maintenance_time)
+        if weekly_period is not None:
+            pulumi.set(__self__, "weekly_period", weekly_period)
+
+    @property
+    @pulumi.getter
+    def duration(self) -> Optional[pulumi.Input[str]]:
+        """
+        The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
+        """
+        return pulumi.get(self, "duration")
+
+    @duration.setter
+    def duration(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "duration", value)
+
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether to open the maintenance window. The following parameters take effect only `enable = true`.
+        """
+        return pulumi.get(self, "enable")
+
+    @enable.setter
+    def enable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable", value)
+
+    @property
+    @pulumi.getter(name="maintenanceTime")
+    def maintenance_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        """
+        return pulumi.get(self, "maintenance_time")
+
+    @maintenance_time.setter
+    def maintenance_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "maintenance_time", value)
+
+    @property
+    @pulumi.getter(name="weeklyPeriod")
+    def weekly_period(self) -> Optional[pulumi.Input[str]]:
+        """
+        Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
+
+        for example:
+        ```
+        maintenance_window {
+        enable            = true
+        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+        duration          = "3h"
+        weekly_period     = "Monday,Friday"
+        }
+        ```
+        """
+        return pulumi.get(self, "weekly_period")
+
+    @weekly_period.setter
+    def weekly_period(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "weekly_period", value)
+
+
+if not MYPY:
+    class ServerlessKubernetesOperationPolicyArgsDict(TypedDict):
+        cluster_auto_upgrade: NotRequired[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict']]
+        """
+        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+elif False:
+    ServerlessKubernetesOperationPolicyArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServerlessKubernetesOperationPolicyArgs:
+    def __init__(__self__, *,
+                 cluster_auto_upgrade: Optional[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs']] = None):
+        """
+        :param pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs'] cluster_auto_upgrade: Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+        if cluster_auto_upgrade is not None:
+            pulumi.set(__self__, "cluster_auto_upgrade", cluster_auto_upgrade)
+
+    @property
+    @pulumi.getter(name="clusterAutoUpgrade")
+    def cluster_auto_upgrade(self) -> Optional[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs']]:
+        """
+        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+        return pulumi.get(self, "cluster_auto_upgrade")
+
+    @cluster_auto_upgrade.setter
+    def cluster_auto_upgrade(self, value: Optional[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs']]):
+        pulumi.set(self, "cluster_auto_upgrade", value)
+
+
+if not MYPY:
+    class ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict(TypedDict):
+        channel: NotRequired[pulumi.Input[str]]
+        """
+        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+
+        for example:
+        ```
+        operation_policy {
+        cluster_auto_upgrade {
+        enabled = true
+        channel = "stable"
+        }
+        }
+        ```
+        """
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether the RRSA feature has been enabled.
+        """
+elif False:
+    ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs:
+    def __init__(__self__, *,
+                 channel: Optional[pulumi.Input[str]] = None,
+                 enabled: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[str] channel: The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+               
+               for example:
+               ```
+               operation_policy {
+               cluster_auto_upgrade {
+               enabled = true
+               channel = "stable"
+               }
+               }
+               ```
+        :param pulumi.Input[bool] enabled: Whether the RRSA feature has been enabled.
+        """
+        if channel is not None:
+            pulumi.set(__self__, "channel", channel)
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def channel(self) -> Optional[pulumi.Input[str]]:
+        """
+        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+
+        for example:
+        ```
+        operation_policy {
+        cluster_auto_upgrade {
+        enabled = true
+        channel = "stable"
+        }
+        }
+        ```
+        """
+        return pulumi.get(self, "channel")
+
+    @channel.setter
+    def channel(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "channel", value)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether the RRSA feature has been enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enabled", value)
+
+
+if not MYPY:
+    class ServerlessKubernetesRrsaMetadataArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether the RRSA feature has been enabled.
+        """
+        ram_oidc_provider_arn: NotRequired[pulumi.Input[str]]
+        """
+        The arn of OIDC provider that was registered in RAM.
+        """
+        ram_oidc_provider_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of OIDC Provider that was registered in RAM.
+        """
+        rrsa_oidc_issuer_url: NotRequired[pulumi.Input[str]]
+        """
+        The issuer URL of RRSA OIDC Token.
+        """
+elif False:
+    ServerlessKubernetesRrsaMetadataArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ServerlessKubernetesRrsaMetadataArgs:
@@ -2311,6 +4597,16 @@ class ServerlessKubernetesRrsaMetadataArgs:
         pulumi.set(self, "rrsa_oidc_issuer_url", value)
 
 
+if not MYPY:
+    class SwarmNodeArgsDict(TypedDict):
+        eip: NotRequired[pulumi.Input[str]]
+        id: NotRequired[pulumi.Input[str]]
+        name: NotRequired[pulumi.Input[str]]
+        private_ip: NotRequired[pulumi.Input[str]]
+        status: NotRequired[pulumi.Input[str]]
+elif False:
+    SwarmNodeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SwarmNodeArgs:
     def __init__(__self__, *,
@@ -2376,103 +4672,3 @@ class SwarmNodeArgs:
         pulumi.set(self, "status", value)
 
 
-@pulumi.input_type
-class GetKubernetesPermissionPermissionArgs:
-    def __init__(__self__, *,
-                 resource_id: str,
-                 resource_type: str,
-                 role_name: str,
-                 is_owner: Optional[bool] = None,
-                 is_ram_role: Optional[bool] = None,
-                 role_type: Optional[str] = None):
-        """
-        :param str resource_id: The permission settings to manage ACK clusters.
-        :param str resource_type: The authorization type. Valid values `cluster`, `namespace` and `console`.
-        :param str role_name: The name of the predefined role. If a custom role is assigned, the value is the name of the assigined custom role.
-        :param bool is_owner: ndicates whether the permissions are granted to the cluster owner. Valid values `0`, `1`.
-        :param bool is_ram_role: Indicates whether the permissions are granted to the RAM role. Valid values `0`,`1`.
-        :param str role_type: The predefined role. Valid values `admin`,`ops`,`dev`,`restricted` and `custom`.
-        """
-        pulumi.set(__self__, "resource_id", resource_id)
-        pulumi.set(__self__, "resource_type", resource_type)
-        pulumi.set(__self__, "role_name", role_name)
-        if is_owner is not None:
-            pulumi.set(__self__, "is_owner", is_owner)
-        if is_ram_role is not None:
-            pulumi.set(__self__, "is_ram_role", is_ram_role)
-        if role_type is not None:
-            pulumi.set(__self__, "role_type", role_type)
-
-    @property
-    @pulumi.getter(name="resourceId")
-    def resource_id(self) -> str:
-        """
-        The permission settings to manage ACK clusters.
-        """
-        return pulumi.get(self, "resource_id")
-
-    @resource_id.setter
-    def resource_id(self, value: str):
-        pulumi.set(self, "resource_id", value)
-
-    @property
-    @pulumi.getter(name="resourceType")
-    def resource_type(self) -> str:
-        """
-        The authorization type. Valid values `cluster`, `namespace` and `console`.
-        """
-        return pulumi.get(self, "resource_type")
-
-    @resource_type.setter
-    def resource_type(self, value: str):
-        pulumi.set(self, "resource_type", value)
-
-    @property
-    @pulumi.getter(name="roleName")
-    def role_name(self) -> str:
-        """
-        The name of the predefined role. If a custom role is assigned, the value is the name of the assigined custom role.
-        """
-        return pulumi.get(self, "role_name")
-
-    @role_name.setter
-    def role_name(self, value: str):
-        pulumi.set(self, "role_name", value)
-
-    @property
-    @pulumi.getter(name="isOwner")
-    def is_owner(self) -> Optional[bool]:
-        """
-        ndicates whether the permissions are granted to the cluster owner. Valid values `0`, `1`.
-        """
-        return pulumi.get(self, "is_owner")
-
-    @is_owner.setter
-    def is_owner(self, value: Optional[bool]):
-        pulumi.set(self, "is_owner", value)
-
-    @property
-    @pulumi.getter(name="isRamRole")
-    def is_ram_role(self) -> Optional[bool]:
-        """
-        Indicates whether the permissions are granted to the RAM role. Valid values `0`,`1`.
-        """
-        return pulumi.get(self, "is_ram_role")
-
-    @is_ram_role.setter
-    def is_ram_role(self, value: Optional[bool]):
-        pulumi.set(self, "is_ram_role", value)
-
-    @property
-    @pulumi.getter(name="roleType")
-    def role_type(self) -> Optional[str]:
-        """
-        The predefined role. Valid values `admin`,`ops`,`dev`,`restricted` and `custom`.
-        """
-        return pulumi.get(self, "role_type")
-
-    @role_type.setter
-    def role_type(self, value: Optional[str]):
-        pulumi.set(self, "role_type", value)
-
-