pulumi-alicloud 3.53.0a1713354491__py3-none-any.whl → 3.73.0a1736850863__py3-none-any.whl

pulumi_alicloud/cs/_inputs.py

@@ -4,51 +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',
+    'NodePoolRollingPolicyArgsDict',
     'NodePoolScalingConfigArgs',
+    'NodePoolScalingConfigArgsDict',
     'NodePoolSpotPriceLimitArgs',
+    'NodePoolSpotPriceLimitArgsDict',
     'NodePoolTaintArgs',
+    'NodePoolTaintArgsDict',
     'NodePoolTeeConfigArgs',
+    'NodePoolTeeConfigArgsDict',
     'ServerlessKubernetesAddonArgs',
+    'ServerlessKubernetesAddonArgsDict',
+    'ServerlessKubernetesDeleteOptionArgs',
+    'ServerlessKubernetesDeleteOptionArgsDict',
+    'ServerlessKubernetesMaintenanceWindowArgs',
+    'ServerlessKubernetesMaintenanceWindowArgsDict',
+    'ServerlessKubernetesOperationPolicyArgs',
+    'ServerlessKubernetesOperationPolicyArgsDict',
+    'ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs',
+    'ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict',
     'ServerlessKubernetesRrsaMetadataArgs',
+    'ServerlessKubernetesRrsaMetadataArgsDict',
     'SwarmNodeArgs',
+    '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__, *,
@@ -102,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__, *,
@@ -167,6 +246,40 @@ 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__, *,
@@ -264,6 +377,23 @@ class EdgeKubernetesAddonArgs:
         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:
     def __init__(__self__, *,
@@ -319,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__, *,
@@ -390,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__, *,
@@ -428,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)
@@ -446,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")
 
@@ -458,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")
 
@@ -467,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__, *,
@@ -618,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__, *,
@@ -673,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__, *,
@@ -770,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__, *,
@@ -825,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__, *,
@@ -880,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__, *,
@@ -951,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__, *,
@@ -1006,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__, *,
@@ -1016,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, When `role_type` value is `all-clusters`, the value of `role_type` must be null.
+        :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` and `all-clusters`.
-        :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[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.
         """
@@ -1037,7 +1573,7 @@ class KubernetesPermissionPermissionArgs:
     @pulumi.getter
     def cluster(self) -> pulumi.Input[str]:
         """
-        The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `role_type` must be null.
+        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")
 
@@ -1073,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")
 
@@ -1106,14 +1642,45 @@ 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)
@@ -1124,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")
 
@@ -1136,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")
 
@@ -1145,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__, *,
@@ -1236,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__, *,
@@ -1291,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__, *,
@@ -1362,73 +2007,247 @@ 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:
                ```
                maintenance_window {
                enable            = true
-               maintenance_time  = "01:00:00Z"
+               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.
 
@@ -1436,7 +2255,7 @@ class ManagedKubernetesMaintenanceWindowArgs:
         ```
         maintenance_window {
         enable            = true
-        maintenance_time  = "01:00:00Z"
+        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
         duration          = "3h"
         weekly_period     = "Monday,Friday"
         }
@@ -1445,10 +2264,145 @@ class ManagedKubernetesMaintenanceWindowArgs:
         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__, *,
@@ -1520,33 +2474,102 @@ 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[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 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 (-).
+        :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:
@@ -1557,8 +2580,12 @@ class NodePoolDataDiskArgs:
             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:
@@ -1570,6 +2597,18 @@ class NodePoolDataDiskArgs:
         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]]:
@@ -1630,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]]:
@@ -1643,14 +2694,26 @@ class NodePoolDataDiskArgs:
         pulumi.set(self, "kms_key_id", value)
 
     @property
-    @pulumi.getter
-    def name(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="mountTarget")
+    def mount_target(self) -> Optional[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 (-).
+        The type of the mounted file system. Works when auto_format is true. Optional value: `ext4`, `xfs`.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "mount_target")
 
-    @name.setter
+    @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 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")
+
+    @name.setter
     def name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "name", value)
 
@@ -1703,6 +2766,87 @@ class NodePoolDataDiskArgs:
         pulumi.set(self, "snapshot_id", value)
 
 
+if not MYPY:
+    class NodePoolKubeletConfigurationArgsDict(TypedDict):
+        allowed_unsafe_sysctls: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        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__, *,
@@ -1712,19 +2856,19 @@ class NodePoolKubeletConfigurationArgs:
                  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,
+                 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, Any]]] = 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, Any]]] = 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.
@@ -1732,19 +2876,19 @@ class NodePoolKubeletConfigurationArgs:
         :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[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, 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[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)
@@ -1859,38 +3003,38 @@ 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
@@ -1931,14 +3075,14 @@ 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
@@ -2003,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__, *,
@@ -2052,6 +3209,51 @@ 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__, *,
@@ -2202,13 +3404,11 @@ class NodePoolManagementArgs:
 
     @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.
         """
-        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.""")
-
         return pulumi.get(self, "surge")
 
     @surge.setter
@@ -2217,13 +3417,11 @@ 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.
         """
-        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.""")
-
         return pulumi.get(self, "surge_percentage")
 
     @surge_percentage.setter
@@ -2231,6 +3429,15 @@ 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 NodePoolManagementAutoRepairPolicyArgs:
     def __init__(__self__, *,
@@ -2254,6 +3461,15 @@ class NodePoolManagementAutoRepairPolicyArgs:
         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 NodePoolManagementAutoUpgradePolicyArgs:
     def __init__(__self__, *,
@@ -2277,6 +3493,19 @@ class NodePoolManagementAutoUpgradePolicyArgs:
         pulumi.set(self, "auto_upgrade_kubelet", 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 NodePoolManagementAutoVulFixPolicyArgs:
     def __init__(__self__, *,
@@ -2316,6 +3545,19 @@ class NodePoolManagementAutoVulFixPolicyArgs:
         pulumi.set(self, "vul_level", value)
 
 
+if not MYPY:
+    class NodePoolPrivatePoolOptionsArgsDict(TypedDict):
+        private_pool_options_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the private node pool.
+        """
+        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]
+
 @pulumi.input_type
 class NodePoolPrivatePoolOptionsArgs:
     def __init__(__self__, *,
@@ -2355,6 +3597,15 @@ class NodePoolPrivatePoolOptionsArgs:
         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__, *,
@@ -2378,6 +3629,39 @@ class NodePoolRollingPolicyArgs:
         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__, *,
@@ -2390,7 +3674,7 @@ class NodePoolScalingConfigArgs:
                  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. It works if `is_bond_eip=true`. `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[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`.
@@ -2428,7 +3712,7 @@ class NodePoolScalingConfigArgs:
     @pulumi.getter(name="eipInternetChargeType")
     def eip_internet_charge_type(self) -> Optional[pulumi.Input[str]]:
         """
-        EIP billing type. It works if `is_bond_eip=true`. `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.
+        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")
 
@@ -2497,6 +3781,19 @@ 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__, *,
@@ -2536,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__, *,
@@ -2590,6 +3904,15 @@ 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__, *,
@@ -2613,12 +3936,63 @@ class NodePoolTeeConfigArgs:
         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. For more config information, see cs_kubernetes_addon_metadata.
         :param pulumi.Input[bool] disabled: Disables the automatic installation of a component. Default is `false`.
@@ -2626,7 +4000,7 @@ class ServerlessKubernetesAddonArgs:
                The following example is the definition of addons block, The type of this field is list:
                
                ```
-               # install nginx ingress, conflict with SLB ingress
+               # install nginx ingress, conflict with ALB ingress
                addons {
                name = "nginx-ingress-controller"
                # use internet
@@ -2634,7 +4008,7 @@ class ServerlessKubernetesAddonArgs:
                # if use intranet, detail below.
                # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
                }
-               # install SLB ingress, conflict with nginx ingress
+               # install ALB ingress, conflict with nginx ingress
                addons {
                name = "alb-ingress-controller"
                }
@@ -2649,11 +4023,10 @@ class ServerlessKubernetesAddonArgs:
                # install prometheus
                addons {
                name = "arms-prometheus"
-               # prometheus also provides managed version, specify with name `managed-arms-prometheus` for professional serverless clusters
-               # name = "managed-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)
@@ -2661,6 +4034,8 @@ 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
@@ -2683,7 +4058,7 @@ class ServerlessKubernetesAddonArgs:
         The following example is the definition of addons block, The type of this field is list:
 
         ```
-        # install nginx ingress, conflict with SLB ingress
+        # install nginx ingress, conflict with ALB ingress
         addons {
         name = "nginx-ingress-controller"
         # use internet
@@ -2691,7 +4066,7 @@ class ServerlessKubernetesAddonArgs:
         # if use intranet, detail below.
         # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
         }
-        # install SLB ingress, conflict with nginx ingress
+        # install ALB ingress, conflict with nginx ingress
         addons {
         name = "alb-ingress-controller"
         }
@@ -2706,8 +4081,6 @@ class ServerlessKubernetesAddonArgs:
         # install prometheus
         addons {
         name = "arms-prometheus"
-        # prometheus also provides managed version, specify with name `managed-arms-prometheus` for professional serverless clusters
-        # name = "managed-arms-prometheus"
         }
         ```
         """
@@ -2729,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:
@@ -2801,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__, *,