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

pulumi_alicloud/cs/outputs.py

@@ -4,9 +4,14 @@
 
 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
 from . import outputs
 
@@ -24,24 +29,36 @@ __all__ = [
     'KubernetesAutoscalerNodepool',
     'KubernetesCertificateAuthority',
     'KubernetesConnections',
+    'KubernetesDeleteOption',
     'KubernetesMasterNode',
     'KubernetesPermissionPermission',
     'KubernetesRuntime',
     'ManagedKubernetesAddon',
     'ManagedKubernetesCertificateAuthority',
     'ManagedKubernetesConnections',
+    'ManagedKubernetesDeleteOption',
     'ManagedKubernetesMaintenanceWindow',
+    'ManagedKubernetesOperationPolicy',
+    'ManagedKubernetesOperationPolicyClusterAutoUpgrade',
     'ManagedKubernetesRrsaMetadata',
     'NodePoolDataDisk',
     'NodePoolKubeletConfiguration',
     'NodePoolLabel',
     'NodePoolManagement',
+    'NodePoolManagementAutoRepairPolicy',
+    'NodePoolManagementAutoUpgradePolicy',
+    'NodePoolManagementAutoVulFixPolicy',
+    'NodePoolPrivatePoolOptions',
     'NodePoolRollingPolicy',
-    'NodePoolRolloutPolicy',
     'NodePoolScalingConfig',
     'NodePoolSpotPriceLimit',
     'NodePoolTaint',
+    'NodePoolTeeConfig',
     'ServerlessKubernetesAddon',
+    'ServerlessKubernetesDeleteOption',
+    'ServerlessKubernetesMaintenanceWindow',
+    'ServerlessKubernetesOperationPolicy',
+    'ServerlessKubernetesOperationPolicyClusterAutoUpgrade',
     'ServerlessKubernetesRrsaMetadata',
     'SwarmNode',
     'GetClusterCredentialCertificateAuthorityResult',
@@ -174,13 +191,26 @@ class EdgeKubernetesAddon(dict):
     def __init__(__self__, *,
                  config: Optional[str] = None,
                  disabled: Optional[bool] = None,
-                 name: Optional[str] = None):
+                 name: Optional[str] = None,
+                 version: Optional[str] = None):
         """
-        :param str config: The ACK add-on configurations.
+        :param str config: The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         :param bool disabled: Disables the automatic installation of a component. Default is `false`.
                
                The following example is the definition of addons block, The type of this field is list:
+               
+               ```
+               # install nginx ingress, conflict with SLB ingress
+               addons {
+               name = "nginx-ingress-controller"
+               # use internet
+               config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               # if use intranet, detail below.
+               # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               }
+               ```
         :param 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 str version: It specifies the version of the component.
         """
         if config is not None:
             pulumi.set(__self__, "config", config)
@@ -188,12 +218,14 @@ class EdgeKubernetesAddon(dict):
             pulumi.set(__self__, "disabled", disabled)
         if name is not None:
             pulumi.set(__self__, "name", name)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
 
     @property
     @pulumi.getter
     def config(self) -> Optional[str]:
         """
-        The ACK add-on configurations.
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -204,6 +236,17 @@ class EdgeKubernetesAddon(dict):
         Disables the automatic installation of a component. Default is `false`.
 
         The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with SLB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        ```
         """
         return pulumi.get(self, "disabled")
 
@@ -215,6 +258,14 @@ class EdgeKubernetesAddon(dict):
         """
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[str]:
+        """
+        It specifies the version of the component.
+        """
+        return pulumi.get(self, "version")
+
 
 @pulumi.output_type
 class EdgeKubernetesCertificateAuthority(dict):
@@ -394,8 +445,17 @@ class EdgeKubernetesRuntime(dict):
                  name: Optional[str] = None,
                  version: Optional[str] = None):
         """
-        :param str name: The kubernetes cluster's name. It is unique in one Alicloud account.
-        :param 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 str name: The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
+        :param 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)
@@ -406,7 +466,7 @@ class EdgeKubernetesRuntime(dict):
     @pulumi.getter
     def name(self) -> Optional[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")
 
@@ -414,7 +474,16 @@ class EdgeKubernetesRuntime(dict):
     @pulumi.getter
     def version(self) -> Optional[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")
 
@@ -625,10 +694,21 @@ class KubernetesAddon(dict):
                  name: Optional[str] = None,
                  version: Optional[str] = None):
         """
-        :param str config: The ACK add-on configurations.
+        :param str config: The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         :param bool disabled: Disables the automatic installation of a component. Default is `false`.
                
                The following example is the definition of addons block, The type of this field is list:
+               
+               ```
+               # install nginx ingress, conflict with SLB ingress
+               addons {
+               name = "nginx-ingress-controller"
+               # use internet
+               config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               # if use intranet, detail below.
+               # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               }
+               ```
         :param 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 str version: The version of the component.
         """
@@ -645,7 +725,7 @@ class KubernetesAddon(dict):
     @pulumi.getter
     def config(self) -> Optional[str]:
         """
-        The ACK add-on configurations.
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -656,6 +736,17 @@ class KubernetesAddon(dict):
         Disables the automatic installation of a component. Default is `false`.
 
         The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with SLB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        ```
         """
         return pulumi.get(self, "disabled")
 
@@ -861,6 +952,114 @@ class KubernetesConnections(dict):
         return pulumi.get(self, "service_domain")
 
 
+@pulumi.output_type
+class KubernetesDeleteOption(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "deleteMode":
+            suggest = "delete_mode"
+        elif key == "resourceType":
+            suggest = "resource_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KubernetesDeleteOption. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KubernetesDeleteOption.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KubernetesDeleteOption.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 delete_mode: Optional[str] = None,
+                 resource_type: Optional[str] = None):
+        """
+        :param str delete_mode: The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        :param 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[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")
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> Optional[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")
+
+
 @pulumi.output_type
 class KubernetesMasterNode(dict):
     @staticmethod
@@ -954,10 +1153,10 @@ class KubernetesPermissionPermission(dict):
                  is_ram_role: Optional[bool] = None,
                  namespace: Optional[str] = None):
         """
-        :param str cluster: The ID of the cluster that you want to manage.
+        :param 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 str role_name: Specifies the predefined role that you want to assign. Valid values `admin`, `ops`, `dev`, `restricted` and the custom cluster roles.
-        :param str role_type: The authorization type. Valid values `cluster`, `namespace`.
-        :param bool is_custom: Specifies whether to perform a custom authorization. To perform a custom authorization, set `role_name` to a custom cluster role.
+        :param str role_type: The authorization type. Valid values `cluster`, `namespace` and `all-clusters`.
+        :param 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 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 str namespace: The namespace to which the permissions are scoped. This parameter is required only if you set role_type to namespace.
         """
@@ -975,7 +1174,7 @@ class KubernetesPermissionPermission(dict):
     @pulumi.getter
     def cluster(self) -> str:
         """
-        The ID of the cluster that you want to manage.
+        The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `cluster` must be `""`.
         """
         return pulumi.get(self, "cluster")
 
@@ -991,7 +1190,7 @@ class KubernetesPermissionPermission(dict):
     @pulumi.getter(name="roleType")
     def role_type(self) -> str:
         """
-        The authorization type. Valid values `cluster`, `namespace`.
+        The authorization type. Valid values `cluster`, `namespace` and `all-clusters`.
         """
         return pulumi.get(self, "role_type")
 
@@ -999,7 +1198,7 @@ class KubernetesPermissionPermission(dict):
     @pulumi.getter(name="isCustom")
     def is_custom(self) -> Optional[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")
 
@@ -1026,8 +1225,17 @@ class KubernetesRuntime(dict):
                  name: Optional[str] = None,
                  version: Optional[str] = None):
         """
-        :param str name: The kubernetes cluster's name. It is unique in one Alicloud account.
-        :param 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 str name: The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
+        :param 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)
@@ -1038,7 +1246,7 @@ class KubernetesRuntime(dict):
     @pulumi.getter
     def name(self) -> Optional[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")
 
@@ -1046,7 +1254,16 @@ class KubernetesRuntime(dict):
     @pulumi.getter
     def version(self) -> Optional[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")
 
@@ -1059,7 +1276,7 @@ class ManagedKubernetesAddon(dict):
                  name: Optional[str] = None,
                  version: Optional[str] = None):
         """
-        :param str config: If this parameter is left empty, no configurations are required.
+        :param str config: If this parameter is left empty, no configurations are required. For more config information, see cs_kubernetes_addon_metadata.
         :param bool disabled: It specifies whether to disable automatic installation. 
                
                It is a new field since 1.75.0. You can specific network plugin, log component,ingress component and so on.
@@ -1087,7 +1304,7 @@ class ManagedKubernetesAddon(dict):
     @pulumi.getter
     def config(self) -> Optional[str]:
         """
-        If this parameter is left empty, no configurations are required.
+        If this parameter is left empty, no configurations are required. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -1268,6 +1485,114 @@ class ManagedKubernetesConnections(dict):
         return pulumi.get(self, "service_domain")
 
 
+@pulumi.output_type
+class ManagedKubernetesDeleteOption(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "deleteMode":
+            suggest = "delete_mode"
+        elif key == "resourceType":
+            suggest = "resource_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ManagedKubernetesDeleteOption. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ManagedKubernetesDeleteOption.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ManagedKubernetesDeleteOption.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 delete_mode: Optional[str] = None,
+                 resource_type: Optional[str] = None):
+        """
+        :param str delete_mode: The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        :param 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[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")
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> Optional[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")
+
+
 @pulumi.output_type
 class ManagedKubernetesMaintenanceWindow(dict):
     @staticmethod
@@ -1290,31 +1615,38 @@ class ManagedKubernetesMaintenanceWindow(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 duration: str,
-                 enable: bool,
-                 maintenance_time: str,
-                 weekly_period: str):
+                 duration: Optional[str] = None,
+                 enable: Optional[bool] = None,
+                 maintenance_time: Optional[str] = None,
+                 weekly_period: Optional[str] = None):
         """
         :param str duration: The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
         :param bool enable: Whether to open the maintenance window. The following parameters take effect only `enable = true`.
-        :param str maintenance_time: Initial maintenance time, For example:"03:00:00Z".
+        :param str maintenance_time: Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
         :param str weekly_period: Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
                
                for example:
-               <!--Start PulumiCodeChooser -->
-               ```python
-               import pulumi
                ```
-               <!--End PulumiCodeChooser -->
+               maintenance_window {
+               enable            = true
+               maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+               duration          = "3h"
+               weekly_period     = "Monday,Friday"
+               }
+               ```
         """
-        pulumi.set(__self__, "duration", duration)
-        pulumi.set(__self__, "enable", enable)
-        pulumi.set(__self__, "maintenance_time", maintenance_time)
-        pulumi.set(__self__, "weekly_period", weekly_period)
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+        if maintenance_time is not None:
+            pulumi.set(__self__, "maintenance_time", maintenance_time)
+        if weekly_period is not None:
+            pulumi.set(__self__, "weekly_period", weekly_period)
 
     @property
     @pulumi.getter
-    def duration(self) -> str:
+    def duration(self) -> Optional[str]:
         """
         The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
         """
@@ -1322,7 +1654,7 @@ class ManagedKubernetesMaintenanceWindow(dict):
 
     @property
     @pulumi.getter
-    def enable(self) -> bool:
+    def enable(self) -> Optional[bool]:
         """
         Whether to open the maintenance window. The following parameters take effect only `enable = true`.
         """
@@ -1330,28 +1662,118 @@ class ManagedKubernetesMaintenanceWindow(dict):
 
     @property
     @pulumi.getter(name="maintenanceTime")
-    def maintenance_time(self) -> str:
+    def maintenance_time(self) -> Optional[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")
 
     @property
     @pulumi.getter(name="weeklyPeriod")
-    def weekly_period(self) -> str:
+    def weekly_period(self) -> Optional[str]:
         """
         Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
 
         for example:
-        <!--Start PulumiCodeChooser -->
-        ```python
-        import pulumi
         ```
-        <!--End PulumiCodeChooser -->
+        maintenance_window {
+        enable            = true
+        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+        duration          = "3h"
+        weekly_period     = "Monday,Friday"
+        }
+        ```
         """
         return pulumi.get(self, "weekly_period")
 
 
+@pulumi.output_type
+class ManagedKubernetesOperationPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clusterAutoUpgrade":
+            suggest = "cluster_auto_upgrade"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ManagedKubernetesOperationPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ManagedKubernetesOperationPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ManagedKubernetesOperationPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cluster_auto_upgrade: Optional['outputs.ManagedKubernetesOperationPolicyClusterAutoUpgrade'] = None):
+        """
+        :param '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['outputs.ManagedKubernetesOperationPolicyClusterAutoUpgrade']:
+        """
+        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+        return pulumi.get(self, "cluster_auto_upgrade")
+
+
+@pulumi.output_type
+class ManagedKubernetesOperationPolicyClusterAutoUpgrade(dict):
+    def __init__(__self__, *,
+                 channel: Optional[str] = None,
+                 enabled: Optional[bool] = None):
+        """
+        :param str channel: The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+               
+               for example:
+               ```
+               operation_policy {
+               cluster_auto_upgrade {
+               enabled = true
+               channel = "stable"
+               }
+               }
+               ```
+        :param 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[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")
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Whether the RRSA feature has been enabled.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class ManagedKubernetesRrsaMetadata(dict):
     @staticmethod
@@ -1433,12 +1855,22 @@ class NodePoolDataDisk(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "autoSnapshotPolicyId":
+        if key == "autoFormat":
+            suggest = "auto_format"
+        elif key == "autoSnapshotPolicyId":
             suggest = "auto_snapshot_policy_id"
+        elif key == "burstingEnabled":
+            suggest = "bursting_enabled"
+        elif key == "fileSystem":
+            suggest = "file_system"
         elif key == "kmsKeyId":
             suggest = "kms_key_id"
+        elif key == "mountTarget":
+            suggest = "mount_target"
         elif key == "performanceLevel":
             suggest = "performance_level"
+        elif key == "provisionedIops":
+            suggest = "provisioned_iops"
         elif key == "snapshotId":
             suggest = "snapshot_id"
 
@@ -1454,45 +1886,73 @@ class NodePoolDataDisk(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 auto_format: Optional[str] = None,
                  auto_snapshot_policy_id: Optional[str] = None,
+                 bursting_enabled: Optional[bool] = None,
                  category: Optional[str] = None,
                  device: Optional[str] = None,
                  encrypted: Optional[str] = None,
+                 file_system: Optional[str] = None,
                  kms_key_id: Optional[str] = None,
+                 mount_target: Optional[str] = None,
                  name: Optional[str] = None,
                  performance_level: Optional[str] = None,
+                 provisioned_iops: Optional[int] = None,
                  size: Optional[int] = None,
                  snapshot_id: Optional[str] = None):
         """
+        :param str auto_format: Whether to automatically mount the data disk. Valid values: true and false.
         :param str auto_snapshot_policy_id: The ID of the automatic snapshot policy that you want to apply to the system disk.
-        :param str category: The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd` and `cloud_essd`.
+        :param bool bursting_enabled: Whether the data disk is enabled with Burst (performance Burst). This is configured when the disk type is cloud_auto.
+        :param str category: The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd`, `cloud_essd`, `cloud_auto`.
         :param 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 str encrypted: Specifies whether to encrypt data disks. Valid values: true and false. Default to `false`.
+        :param str file_system: The Mount path. Works when auto_format is true.
         :param str kms_key_id: The kms key id used to encrypt the data disk. It takes effect when `encrypted` is true.
-        :param str name: The name of data disk N. Valid values of N: 1 to 16. The name must be 2 to 128 characters in length, and can contain letters, digits, colons (:), underscores (_), and hyphens (-). The name must start with a letter but cannot start with http:// or https://.
+        :param str mount_target: The type of the mounted file system. Works when auto_format is true. Optional value: `ext4`, `xfs`.
+        :param 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 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 int provisioned_iops: The read/write IOPS preconfigured for the data disk, which is configured when the disk type is cloud_auto.
         :param int size: The size of a data disk, Its valid value range [40~32768] in GB. Default to `40`.
         :param str snapshot_id: The ID of the snapshot that you want to use to create data disk N. Valid values of N: 1 to 16. If you specify this parameter, DataDisk.N.Size is ignored. The size of the disk is the same as the size of the specified snapshot. If you specify a snapshot that is created on or before July 15, 2013, the operation fails and InvalidSnapshot.TooOld is returned.
         """
+        if auto_format is not None:
+            pulumi.set(__self__, "auto_format", auto_format)
         if auto_snapshot_policy_id is not None:
             pulumi.set(__self__, "auto_snapshot_policy_id", auto_snapshot_policy_id)
+        if bursting_enabled is not None:
+            pulumi.set(__self__, "bursting_enabled", bursting_enabled)
         if category is not None:
             pulumi.set(__self__, "category", category)
         if device is not None:
             pulumi.set(__self__, "device", device)
         if encrypted is not None:
             pulumi.set(__self__, "encrypted", encrypted)
+        if file_system is not None:
+            pulumi.set(__self__, "file_system", file_system)
         if kms_key_id is not None:
             pulumi.set(__self__, "kms_key_id", kms_key_id)
+        if mount_target is not None:
+            pulumi.set(__self__, "mount_target", mount_target)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if performance_level is not None:
             pulumi.set(__self__, "performance_level", performance_level)
+        if provisioned_iops is not None:
+            pulumi.set(__self__, "provisioned_iops", provisioned_iops)
         if size is not None:
             pulumi.set(__self__, "size", size)
         if snapshot_id is not None:
             pulumi.set(__self__, "snapshot_id", snapshot_id)
 
+    @property
+    @pulumi.getter(name="autoFormat")
+    def auto_format(self) -> Optional[str]:
+        """
+        Whether to automatically mount the data disk. Valid values: true and false.
+        """
+        return pulumi.get(self, "auto_format")
+
     @property
     @pulumi.getter(name="autoSnapshotPolicyId")
     def auto_snapshot_policy_id(self) -> Optional[str]:
@@ -1501,11 +1961,19 @@ class NodePoolDataDisk(dict):
         """
         return pulumi.get(self, "auto_snapshot_policy_id")
 
+    @property
+    @pulumi.getter(name="burstingEnabled")
+    def bursting_enabled(self) -> Optional[bool]:
+        """
+        Whether the data disk is enabled with Burst (performance Burst). This is configured when the disk type is cloud_auto.
+        """
+        return pulumi.get(self, "bursting_enabled")
+
     @property
     @pulumi.getter
     def category(self) -> Optional[str]:
         """
-        The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd` and `cloud_essd`.
+        The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd`, `cloud_essd`, `cloud_auto`.
         """
         return pulumi.get(self, "category")
 
@@ -1525,6 +1993,14 @@ class NodePoolDataDisk(dict):
         """
         return pulumi.get(self, "encrypted")
 
+    @property
+    @pulumi.getter(name="fileSystem")
+    def file_system(self) -> Optional[str]:
+        """
+        The Mount path. Works when auto_format is true.
+        """
+        return pulumi.get(self, "file_system")
+
     @property
     @pulumi.getter(name="kmsKeyId")
     def kms_key_id(self) -> Optional[str]:
@@ -1533,11 +2009,19 @@ class NodePoolDataDisk(dict):
         """
         return pulumi.get(self, "kms_key_id")
 
+    @property
+    @pulumi.getter(name="mountTarget")
+    def mount_target(self) -> Optional[str]:
+        """
+        The type of the mounted file system. Works when auto_format is true. Optional value: `ext4`, `xfs`.
+        """
+        return pulumi.get(self, "mount_target")
+
     @property
     @pulumi.getter
     def name(self) -> Optional[str]:
         """
-        The name of data disk N. Valid values of N: 1 to 16. The name must be 2 to 128 characters in length, and can contain letters, digits, colons (:), underscores (_), and hyphens (-). The name must start with a letter but cannot start with http:// or https://.
+        The length is 2~128 English or Chinese characters. It must start with an uppercase or lowr letter or a Chinese character and cannot start with http:// or https. Can contain numbers, colons (:), underscores (_), or dashes (-). It will be overwritten if auto_format is set.
         """
         return pulumi.get(self, "name")
 
@@ -1549,6 +2033,14 @@ class NodePoolDataDisk(dict):
         """
         return pulumi.get(self, "performance_level")
 
+    @property
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> Optional[int]:
+        """
+        The read/write IOPS preconfigured for the data disk, which is configured when the disk type is cloud_auto.
+        """
+        return pulumi.get(self, "provisioned_iops")
+
     @property
     @pulumi.getter
     def size(self) -> Optional[int]:
@@ -1571,7 +2063,13 @@ class NodePoolKubeletConfiguration(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "cpuManagerPolicy":
+        if key == "allowedUnsafeSysctls":
+            suggest = "allowed_unsafe_sysctls"
+        elif key == "containerLogMaxFiles":
+            suggest = "container_log_max_files"
+        elif key == "containerLogMaxSize":
+            suggest = "container_log_max_size"
+        elif key == "cpuManagerPolicy":
             suggest = "cpu_manager_policy"
         elif key == "eventBurst":
             suggest = "event_burst"
@@ -1583,12 +2081,18 @@ class NodePoolKubeletConfiguration(dict):
             suggest = "eviction_soft"
         elif key == "evictionSoftGracePeriod":
             suggest = "eviction_soft_grace_period"
+        elif key == "featureGates":
+            suggest = "feature_gates"
         elif key == "kubeApiBurst":
             suggest = "kube_api_burst"
         elif key == "kubeApiQps":
             suggest = "kube_api_qps"
         elif key == "kubeReserved":
             suggest = "kube_reserved"
+        elif key == "maxPods":
+            suggest = "max_pods"
+        elif key == "readOnlyPort":
+            suggest = "read_only_port"
         elif key == "registryBurst":
             suggest = "registry_burst"
         elif key == "registryPullQps":
@@ -1610,34 +2114,52 @@ class NodePoolKubeletConfiguration(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 allowed_unsafe_sysctls: Optional[Sequence[str]] = None,
+                 container_log_max_files: Optional[str] = None,
+                 container_log_max_size: Optional[str] = None,
                  cpu_manager_policy: Optional[str] = None,
                  event_burst: Optional[str] = None,
                  event_record_qps: Optional[str] = None,
-                 eviction_hard: Optional[Mapping[str, Any]] = None,
-                 eviction_soft: Optional[Mapping[str, Any]] = None,
-                 eviction_soft_grace_period: Optional[Mapping[str, Any]] = None,
+                 eviction_hard: Optional[Mapping[str, str]] = None,
+                 eviction_soft: Optional[Mapping[str, str]] = None,
+                 eviction_soft_grace_period: Optional[Mapping[str, str]] = None,
+                 feature_gates: Optional[Mapping[str, bool]] = None,
                  kube_api_burst: Optional[str] = None,
                  kube_api_qps: Optional[str] = None,
-                 kube_reserved: Optional[Mapping[str, Any]] = None,
+                 kube_reserved: Optional[Mapping[str, str]] = None,
+                 max_pods: Optional[str] = None,
+                 read_only_port: Optional[str] = None,
                  registry_burst: Optional[str] = None,
                  registry_pull_qps: Optional[str] = None,
                  serialize_image_pulls: Optional[str] = None,
-                 system_reserved: Optional[Mapping[str, Any]] = None):
+                 system_reserved: Optional[Mapping[str, str]] = None):
         """
+        :param Sequence[str] allowed_unsafe_sysctls: Allowed sysctl mode whitelist.
+        :param str container_log_max_files: The maximum number of log files that can exist in each container.
+        :param str container_log_max_size: The maximum size that can be reached before a log file is rotated.
         :param 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 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 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 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 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 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 Mapping[str, str] eviction_hard: Same as evictionHard. The map of signal names to quantities that defines hard eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
+        :param Mapping[str, str] eviction_soft: Same as evictionSoft. The map of signal names to quantities that defines soft eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
+        :param Mapping[str, 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 Mapping[str, bool] feature_gates: Feature switch to enable configuration of experimental features.
         :param str kube_api_burst: Same as kubeAPIBurst. The burst to allow while talking with kubernetes api-server. Valid value is `[0-100]`.
         :param str kube_api_qps: Same as kubeAPIQPS. The QPS to use while talking with kubernetes api-server. Valid value is `[0-50]`.
-        :param 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 Mapping[str, 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 str max_pods: The maximum number of running pods.
+        :param str read_only_port: Read-only port number.
         :param 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 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 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 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 Mapping[str, str] system_reserved: Same as systemReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for non-kubernetes components. Currently, only cpu and memory are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
+        """
+        if allowed_unsafe_sysctls is not None:
+            pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
+        if container_log_max_files is not None:
+            pulumi.set(__self__, "container_log_max_files", container_log_max_files)
+        if container_log_max_size is not None:
+            pulumi.set(__self__, "container_log_max_size", container_log_max_size)
         if cpu_manager_policy is not None:
             pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
         if event_burst is not None:
@@ -1650,12 +2172,18 @@ class NodePoolKubeletConfiguration(dict):
             pulumi.set(__self__, "eviction_soft", eviction_soft)
         if eviction_soft_grace_period is not None:
             pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period)
+        if feature_gates is not None:
+            pulumi.set(__self__, "feature_gates", feature_gates)
         if kube_api_burst is not None:
             pulumi.set(__self__, "kube_api_burst", kube_api_burst)
         if kube_api_qps is not None:
             pulumi.set(__self__, "kube_api_qps", kube_api_qps)
         if kube_reserved is not None:
             pulumi.set(__self__, "kube_reserved", kube_reserved)
+        if max_pods is not None:
+            pulumi.set(__self__, "max_pods", max_pods)
+        if read_only_port is not None:
+            pulumi.set(__self__, "read_only_port", read_only_port)
         if registry_burst is not None:
             pulumi.set(__self__, "registry_burst", registry_burst)
         if registry_pull_qps is not None:
@@ -1665,6 +2193,30 @@ class NodePoolKubeletConfiguration(dict):
         if system_reserved is not None:
             pulumi.set(__self__, "system_reserved", system_reserved)
 
+    @property
+    @pulumi.getter(name="allowedUnsafeSysctls")
+    def allowed_unsafe_sysctls(self) -> Optional[Sequence[str]]:
+        """
+        Allowed sysctl mode whitelist.
+        """
+        return pulumi.get(self, "allowed_unsafe_sysctls")
+
+    @property
+    @pulumi.getter(name="containerLogMaxFiles")
+    def container_log_max_files(self) -> Optional[str]:
+        """
+        The maximum number of log files that can exist in each container.
+        """
+        return pulumi.get(self, "container_log_max_files")
+
+    @property
+    @pulumi.getter(name="containerLogMaxSize")
+    def container_log_max_size(self) -> Optional[str]:
+        """
+        The maximum size that can be reached before a log file is rotated.
+        """
+        return pulumi.get(self, "container_log_max_size")
+
     @property
     @pulumi.getter(name="cpuManagerPolicy")
     def cpu_manager_policy(self) -> Optional[str]:
@@ -1691,7 +2243,7 @@ class NodePoolKubeletConfiguration(dict):
 
     @property
     @pulumi.getter(name="evictionHard")
-    def eviction_hard(self) -> Optional[Mapping[str, Any]]:
+    def eviction_hard(self) -> Optional[Mapping[str, str]]:
         """
         Same as evictionHard. The map of signal names to quantities that defines hard eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
         """
@@ -1699,7 +2251,7 @@ class NodePoolKubeletConfiguration(dict):
 
     @property
     @pulumi.getter(name="evictionSoft")
-    def eviction_soft(self) -> Optional[Mapping[str, Any]]:
+    def eviction_soft(self) -> Optional[Mapping[str, str]]:
         """
         Same as evictionSoft. The map of signal names to quantities that defines soft eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
         """
@@ -1707,12 +2259,20 @@ class NodePoolKubeletConfiguration(dict):
 
     @property
     @pulumi.getter(name="evictionSoftGracePeriod")
-    def eviction_soft_grace_period(self) -> Optional[Mapping[str, Any]]:
+    def eviction_soft_grace_period(self) -> Optional[Mapping[str, 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")
 
+    @property
+    @pulumi.getter(name="featureGates")
+    def feature_gates(self) -> Optional[Mapping[str, bool]]:
+        """
+        Feature switch to enable configuration of experimental features.
+        """
+        return pulumi.get(self, "feature_gates")
+
     @property
     @pulumi.getter(name="kubeApiBurst")
     def kube_api_burst(self) -> Optional[str]:
@@ -1731,12 +2291,28 @@ class NodePoolKubeletConfiguration(dict):
 
     @property
     @pulumi.getter(name="kubeReserved")
-    def kube_reserved(self) -> Optional[Mapping[str, Any]]:
+    def kube_reserved(self) -> Optional[Mapping[str, 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")
 
+    @property
+    @pulumi.getter(name="maxPods")
+    def max_pods(self) -> Optional[str]:
+        """
+        The maximum number of running pods.
+        """
+        return pulumi.get(self, "max_pods")
+
+    @property
+    @pulumi.getter(name="readOnlyPort")
+    def read_only_port(self) -> Optional[str]:
+        """
+        Read-only port number.
+        """
+        return pulumi.get(self, "read_only_port")
+
     @property
     @pulumi.getter(name="registryBurst")
     def registry_burst(self) -> Optional[str]:
@@ -1763,7 +2339,7 @@ class NodePoolKubeletConfiguration(dict):
 
     @property
     @pulumi.getter(name="systemReserved")
-    def system_reserved(self) -> Optional[Mapping[str, Any]]:
+    def system_reserved(self) -> Optional[Mapping[str, 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.
         """
@@ -1805,12 +2381,20 @@ class NodePoolManagement(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "maxUnavailable":
-            suggest = "max_unavailable"
-        elif key == "autoRepair":
+        if key == "autoRepair":
             suggest = "auto_repair"
+        elif key == "autoRepairPolicy":
+            suggest = "auto_repair_policy"
         elif key == "autoUpgrade":
             suggest = "auto_upgrade"
+        elif key == "autoUpgradePolicy":
+            suggest = "auto_upgrade_policy"
+        elif key == "autoVulFix":
+            suggest = "auto_vul_fix"
+        elif key == "autoVulFixPolicy":
+            suggest = "auto_vul_fix_policy"
+        elif key == "maxUnavailable":
+            suggest = "max_unavailable"
         elif key == "surgePercentage":
             suggest = "surge_percentage"
 
@@ -1826,54 +2410,116 @@ class NodePoolManagement(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 max_unavailable: int,
                  auto_repair: Optional[bool] = None,
+                 auto_repair_policy: Optional['outputs.NodePoolManagementAutoRepairPolicy'] = None,
                  auto_upgrade: Optional[bool] = None,
+                 auto_upgrade_policy: Optional['outputs.NodePoolManagementAutoUpgradePolicy'] = None,
+                 auto_vul_fix: Optional[bool] = None,
+                 auto_vul_fix_policy: Optional['outputs.NodePoolManagementAutoVulFixPolicy'] = None,
+                 enable: Optional[bool] = None,
+                 max_unavailable: Optional[int] = None,
                  surge: Optional[int] = None,
                  surge_percentage: Optional[int] = None):
         """
-        :param int max_unavailable: Max number of unavailable nodes. Default to `1`.
-        :param bool auto_repair: Whether automatic repair, Default to `false`.
-        :param bool auto_upgrade: Whether auto upgrade, Default to `false`.
+        :param bool auto_repair: Whether to enable automatic repair. Valid values: `true`: Automatic repair. `false`: not automatically repaired.
+        :param 'NodePoolManagementAutoRepairPolicyArgs' auto_repair_policy: Automatic repair node policy. See `auto_repair_policy` below.
+        :param bool auto_upgrade: Specifies whether to enable auto update. Valid values: `true`: enables auto update. `false`: disables auto update.
+        :param 'NodePoolManagementAutoUpgradePolicyArgs' auto_upgrade_policy: The auto update policy. See `auto_upgrade_policy` below.
+        :param bool auto_vul_fix: Specifies whether to automatically patch CVE vulnerabilities. Valid values: `true`, `false`.
+        :param 'NodePoolManagementAutoVulFixPolicyArgs' auto_vul_fix_policy: The auto CVE patching policy. See `auto_vul_fix_policy` below.
+        :param bool enable: Specifies whether to enable the managed node pool feature. Valid values: `true`: enables the managed node pool feature. `false`: disables the managed node pool feature. Other parameters in this section take effect only when you specify enable=true.
+        :param int max_unavailable: Maximum number of unavailable nodes. Default value: 1. Value range:\\[1,1000\\].
         :param int surge: Number of additional nodes. You have to specify one of surge, surge_percentage.
         :param int surge_percentage: Proportion of additional nodes. You have to specify one of surge, surge_percentage.
         """
-        pulumi.set(__self__, "max_unavailable", max_unavailable)
         if auto_repair is not None:
             pulumi.set(__self__, "auto_repair", auto_repair)
+        if auto_repair_policy is not None:
+            pulumi.set(__self__, "auto_repair_policy", auto_repair_policy)
         if auto_upgrade is not None:
             pulumi.set(__self__, "auto_upgrade", auto_upgrade)
+        if auto_upgrade_policy is not None:
+            pulumi.set(__self__, "auto_upgrade_policy", auto_upgrade_policy)
+        if auto_vul_fix is not None:
+            pulumi.set(__self__, "auto_vul_fix", auto_vul_fix)
+        if auto_vul_fix_policy is not None:
+            pulumi.set(__self__, "auto_vul_fix_policy", auto_vul_fix_policy)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+        if max_unavailable is not None:
+            pulumi.set(__self__, "max_unavailable", max_unavailable)
         if surge is not None:
             pulumi.set(__self__, "surge", surge)
         if surge_percentage is not None:
             pulumi.set(__self__, "surge_percentage", surge_percentage)
 
     @property
-    @pulumi.getter(name="maxUnavailable")
-    def max_unavailable(self) -> int:
+    @pulumi.getter(name="autoRepair")
+    def auto_repair(self) -> Optional[bool]:
         """
-        Max number of unavailable nodes. Default to `1`.
+        Whether to enable automatic repair. Valid values: `true`: Automatic repair. `false`: not automatically repaired.
         """
-        return pulumi.get(self, "max_unavailable")
+        return pulumi.get(self, "auto_repair")
 
     @property
-    @pulumi.getter(name="autoRepair")
-    def auto_repair(self) -> Optional[bool]:
+    @pulumi.getter(name="autoRepairPolicy")
+    def auto_repair_policy(self) -> Optional['outputs.NodePoolManagementAutoRepairPolicy']:
         """
-        Whether automatic repair, Default to `false`.
+        Automatic repair node policy. See `auto_repair_policy` below.
         """
-        return pulumi.get(self, "auto_repair")
+        return pulumi.get(self, "auto_repair_policy")
 
     @property
     @pulumi.getter(name="autoUpgrade")
     def auto_upgrade(self) -> Optional[bool]:
         """
-        Whether auto upgrade, Default to `false`.
+        Specifies whether to enable auto update. Valid values: `true`: enables auto update. `false`: disables auto update.
         """
         return pulumi.get(self, "auto_upgrade")
 
+    @property
+    @pulumi.getter(name="autoUpgradePolicy")
+    def auto_upgrade_policy(self) -> Optional['outputs.NodePoolManagementAutoUpgradePolicy']:
+        """
+        The auto update policy. See `auto_upgrade_policy` below.
+        """
+        return pulumi.get(self, "auto_upgrade_policy")
+
+    @property
+    @pulumi.getter(name="autoVulFix")
+    def auto_vul_fix(self) -> Optional[bool]:
+        """
+        Specifies whether to automatically patch CVE vulnerabilities. Valid values: `true`, `false`.
+        """
+        return pulumi.get(self, "auto_vul_fix")
+
+    @property
+    @pulumi.getter(name="autoVulFixPolicy")
+    def auto_vul_fix_policy(self) -> Optional['outputs.NodePoolManagementAutoVulFixPolicy']:
+        """
+        The auto CVE patching policy. See `auto_vul_fix_policy` below.
+        """
+        return pulumi.get(self, "auto_vul_fix_policy")
+
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[bool]:
+        """
+        Specifies whether to enable the managed node pool feature. Valid values: `true`: enables the managed node pool feature. `false`: disables the managed node pool feature. Other parameters in this section take effect only when you specify enable=true.
+        """
+        return pulumi.get(self, "enable")
+
+    @property
+    @pulumi.getter(name="maxUnavailable")
+    def max_unavailable(self) -> Optional[int]:
+        """
+        Maximum number of unavailable nodes. Default value: 1. Value range:\\[1,1000\\].
+        """
+        return pulumi.get(self, "max_unavailable")
+
     @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[int]:
         """
         Number of additional nodes. You have to specify one of surge, surge_percentage.
@@ -1882,6 +2528,7 @@ class NodePoolManagement(dict):
 
     @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[int]:
         """
         Proportion of additional nodes. You have to specify one of surge, surge_percentage.
@@ -1890,75 +2537,211 @@ class NodePoolManagement(dict):
 
 
 @pulumi.output_type
-class NodePoolRollingPolicy(dict):
+class NodePoolManagementAutoRepairPolicy(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "maxParallelism":
-            suggest = "max_parallelism"
+        if key == "restartNode":
+            suggest = "restart_node"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in NodePoolRollingPolicy. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolManagementAutoRepairPolicy. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        NodePoolRollingPolicy.__key_warning(key)
+        NodePoolManagementAutoRepairPolicy.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        NodePoolRollingPolicy.__key_warning(key)
+        NodePoolManagementAutoRepairPolicy.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 max_parallelism: Optional[int] = None):
+                 restart_node: Optional[bool] = None):
         """
-        :param int max_parallelism: Maximum parallel number nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used.
+        :param bool restart_node: Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
         """
-        if max_parallelism is not None:
-            pulumi.set(__self__, "max_parallelism", max_parallelism)
+        if restart_node is not None:
+            pulumi.set(__self__, "restart_node", restart_node)
 
     @property
-    @pulumi.getter(name="maxParallelism")
-    def max_parallelism(self) -> Optional[int]:
+    @pulumi.getter(name="restartNode")
+    def restart_node(self) -> Optional[bool]:
         """
-        Maximum parallel number nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used.
+        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
         """
-        return pulumi.get(self, "max_parallelism")
+        return pulumi.get(self, "restart_node")
 
 
 @pulumi.output_type
-class NodePoolRolloutPolicy(dict):
+class NodePoolManagementAutoUpgradePolicy(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "maxUnavailable":
-            suggest = "max_unavailable"
+        if key == "autoUpgradeKubelet":
+            suggest = "auto_upgrade_kubelet"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in NodePoolRolloutPolicy. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolManagementAutoUpgradePolicy. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        NodePoolRolloutPolicy.__key_warning(key)
+        NodePoolManagementAutoUpgradePolicy.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        NodePoolRolloutPolicy.__key_warning(key)
+        NodePoolManagementAutoUpgradePolicy.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 max_unavailable: Optional[int] = None):
+                 auto_upgrade_kubelet: Optional[bool] = None):
         """
-        :param int max_unavailable: Maximum number of unavailable nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used. Please use `max_parallelism` to instead it from provider version 1.185.0.
+        :param bool auto_upgrade_kubelet: Specifies whether  to automatically update the kubelet. Valid values: `true`: yes; `false`: no.
         """
-        if max_unavailable is not None:
-            pulumi.set(__self__, "max_unavailable", max_unavailable)
+        if auto_upgrade_kubelet is not None:
+            pulumi.set(__self__, "auto_upgrade_kubelet", auto_upgrade_kubelet)
 
     @property
-    @pulumi.getter(name="maxUnavailable")
-    def max_unavailable(self) -> Optional[int]:
+    @pulumi.getter(name="autoUpgradeKubelet")
+    def auto_upgrade_kubelet(self) -> Optional[bool]:
         """
-        Maximum number of unavailable nodes during rolling upgrade. The value of this field should be greater than `0`, and if it's set to a number less than or equal to `0`, the default setting will be used. Please use `max_parallelism` to instead it from provider version 1.185.0.
+        Specifies whether  to automatically update the kubelet. Valid values: `true`: yes; `false`: no.
         """
-        return pulumi.get(self, "max_unavailable")
+        return pulumi.get(self, "auto_upgrade_kubelet")
+
+
+@pulumi.output_type
+class NodePoolManagementAutoVulFixPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "restartNode":
+            suggest = "restart_node"
+        elif key == "vulLevel":
+            suggest = "vul_level"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolManagementAutoVulFixPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolManagementAutoVulFixPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolManagementAutoVulFixPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 restart_node: Optional[bool] = None,
+                 vul_level: Optional[str] = None):
+        """
+        :param bool restart_node: Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
+        :param str vul_level: The severity levels of vulnerabilities that is allowed to automatically patch. Multiple severity levels are separated by commas (,).
+        """
+        if restart_node is not None:
+            pulumi.set(__self__, "restart_node", restart_node)
+        if vul_level is not None:
+            pulumi.set(__self__, "vul_level", vul_level)
+
+    @property
+    @pulumi.getter(name="restartNode")
+    def restart_node(self) -> Optional[bool]:
+        """
+        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
+        """
+        return pulumi.get(self, "restart_node")
+
+    @property
+    @pulumi.getter(name="vulLevel")
+    def vul_level(self) -> Optional[str]:
+        """
+        The severity levels of vulnerabilities that is allowed to automatically patch. Multiple severity levels are separated by commas (,).
+        """
+        return pulumi.get(self, "vul_level")
+
+
+@pulumi.output_type
+class NodePoolPrivatePoolOptions(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "privatePoolOptionsId":
+            suggest = "private_pool_options_id"
+        elif key == "privatePoolOptionsMatchCriteria":
+            suggest = "private_pool_options_match_criteria"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolPrivatePoolOptions. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolPrivatePoolOptions.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolPrivatePoolOptions.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 private_pool_options_id: Optional[str] = None,
+                 private_pool_options_match_criteria: Optional[str] = None):
+        """
+        :param str private_pool_options_id: The ID of the private node pool.
+        :param str private_pool_options_match_criteria: The type of private node pool. This parameter specifies the type of the private pool that you want to use to create instances. A private node pool is generated when an elasticity assurance or a capacity reservation service takes effect. The system selects a private node pool to launch instances. Valid values: `Open`: specifies an open private node pool. The system selects an open private node pool to launch instances. If no matching open private node pool is available, the resources in the public node pool are used. `Target`: specifies a private node pool. The system uses the resources of the specified private node pool to launch instances. If the specified private node pool is unavailable, instances cannot be started. `None`: no private node pool is used. The resources of private node pools are not used to launch the instances.
+        """
+        if private_pool_options_id is not None:
+            pulumi.set(__self__, "private_pool_options_id", private_pool_options_id)
+        if private_pool_options_match_criteria is not None:
+            pulumi.set(__self__, "private_pool_options_match_criteria", private_pool_options_match_criteria)
+
+    @property
+    @pulumi.getter(name="privatePoolOptionsId")
+    def private_pool_options_id(self) -> Optional[str]:
+        """
+        The ID of the private node pool.
+        """
+        return pulumi.get(self, "private_pool_options_id")
+
+    @property
+    @pulumi.getter(name="privatePoolOptionsMatchCriteria")
+    def private_pool_options_match_criteria(self) -> Optional[str]:
+        """
+        The type of private node pool. This parameter specifies the type of the private pool that you want to use to create instances. A private node pool is generated when an elasticity assurance or a capacity reservation service takes effect. The system selects a private node pool to launch instances. Valid values: `Open`: specifies an open private node pool. The system selects an open private node pool to launch instances. If no matching open private node pool is available, the resources in the public node pool are used. `Target`: specifies a private node pool. The system uses the resources of the specified private node pool to launch instances. If the specified private node pool is unavailable, instances cannot be started. `None`: no private node pool is used. The resources of private node pools are not used to launch the instances.
+        """
+        return pulumi.get(self, "private_pool_options_match_criteria")
+
+
+@pulumi.output_type
+class NodePoolRollingPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxParallelism":
+            suggest = "max_parallelism"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolRollingPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolRollingPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolRollingPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_parallelism: Optional[int] = None):
+        """
+        :param int max_parallelism: The maximum number of unusable nodes.
+        """
+        if max_parallelism is not None:
+            pulumi.set(__self__, "max_parallelism", max_parallelism)
+
+    @property
+    @pulumi.getter(name="maxParallelism")
+    def max_parallelism(self) -> Optional[int]:
+        """
+        The maximum number of unusable nodes.
+        """
+        return pulumi.get(self, "max_parallelism")
 
 
 @pulumi.output_type
@@ -1966,16 +2749,16 @@ class NodePoolScalingConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "maxSize":
-            suggest = "max_size"
-        elif key == "minSize":
-            suggest = "min_size"
-        elif key == "eipBandwidth":
+        if key == "eipBandwidth":
             suggest = "eip_bandwidth"
         elif key == "eipInternetChargeType":
             suggest = "eip_internet_charge_type"
         elif key == "isBondEip":
             suggest = "is_bond_eip"
+        elif key == "maxSize":
+            suggest = "max_size"
+        elif key == "minSize":
+            suggest = "min_size"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in NodePoolScalingConfig. Access the value via the '{suggest}' property getter instead.")
@@ -1989,52 +2772,42 @@ class NodePoolScalingConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 max_size: int,
-                 min_size: int,
                  eip_bandwidth: Optional[int] = None,
                  eip_internet_charge_type: Optional[str] = None,
+                 enable: Optional[bool] = None,
                  is_bond_eip: Optional[bool] = None,
+                 max_size: Optional[int] = None,
+                 min_size: Optional[int] = None,
                  type: Optional[str] = None):
         """
+        :param 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 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 bool enable: Whether to enable automatic scaling. Value:
+        :param bool is_bond_eip: Whether to bind EIP for an instance. Default: `false`.
         :param int max_size: Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
         :param int min_size: Min number of instances in a auto scaling group, its valid value range [0~1000].
-        :param int eip_bandwidth: Peak EIP bandwidth. Its valid value range [1~500] in Mbps. Default to `5`.
-        :param str eip_internet_charge_type: EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. Conflict with `internet_charge_type`, EIP and public network IP can only choose one.
-        :param bool is_bond_eip: Whether to bind EIP for an instance. Default: `false`.
         :param str type: Instance classification, not required. Vaild value: `cpu`, `gpu`, `gpushare` and `spot`. Default: `cpu`. The actual instance type is determined by `instance_types`.
         """
-        pulumi.set(__self__, "max_size", max_size)
-        pulumi.set(__self__, "min_size", min_size)
         if eip_bandwidth is not None:
             pulumi.set(__self__, "eip_bandwidth", eip_bandwidth)
         if eip_internet_charge_type is not None:
             pulumi.set(__self__, "eip_internet_charge_type", eip_internet_charge_type)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
         if is_bond_eip is not None:
             pulumi.set(__self__, "is_bond_eip", is_bond_eip)
+        if max_size is not None:
+            pulumi.set(__self__, "max_size", max_size)
+        if min_size is not None:
+            pulumi.set(__self__, "min_size", min_size)
         if type is not None:
             pulumi.set(__self__, "type", type)
 
-    @property
-    @pulumi.getter(name="maxSize")
-    def max_size(self) -> int:
-        """
-        Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
-        """
-        return pulumi.get(self, "max_size")
-
-    @property
-    @pulumi.getter(name="minSize")
-    def min_size(self) -> int:
-        """
-        Min number of instances in a auto scaling group, its valid value range [0~1000].
-        """
-        return pulumi.get(self, "min_size")
-
     @property
     @pulumi.getter(name="eipBandwidth")
     def eip_bandwidth(self) -> Optional[int]:
         """
-        Peak EIP bandwidth. Its valid value range [1~500] in Mbps. Default to `5`.
+        Peak EIP bandwidth. Its valid value range [1~500] in Mbps. It works if `is_bond_eip=true`. Default to `5`.
         """
         return pulumi.get(self, "eip_bandwidth")
 
@@ -2042,10 +2815,18 @@ class NodePoolScalingConfig(dict):
     @pulumi.getter(name="eipInternetChargeType")
     def eip_internet_charge_type(self) -> Optional[str]:
         """
-        EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. Conflict with `internet_charge_type`, EIP and public network IP can only choose one.
+        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")
 
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[bool]:
+        """
+        Whether to enable automatic scaling. Value:
+        """
+        return pulumi.get(self, "enable")
+
     @property
     @pulumi.getter(name="isBondEip")
     def is_bond_eip(self) -> Optional[bool]:
@@ -2054,6 +2835,22 @@ class NodePoolScalingConfig(dict):
         """
         return pulumi.get(self, "is_bond_eip")
 
+    @property
+    @pulumi.getter(name="maxSize")
+    def max_size(self) -> Optional[int]:
+        """
+        Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
+        """
+        return pulumi.get(self, "max_size")
+
+    @property
+    @pulumi.getter(name="minSize")
+    def min_size(self) -> Optional[int]:
+        """
+        Min number of instances in a auto scaling group, its valid value range [0~1000].
+        """
+        return pulumi.get(self, "min_size")
+
     @property
     @pulumi.getter
     def type(self) -> Optional[str]:
@@ -2088,8 +2885,8 @@ class NodePoolSpotPriceLimit(dict):
                  instance_type: Optional[str] = None,
                  price_limit: Optional[str] = None):
         """
-        :param str instance_type: Spot instance type.
-        :param str price_limit: The maximum hourly price of the spot instance. A maximum of three decimal places are allowed.
+        :param str instance_type: The type of the preemptible instance.
+        :param str price_limit: The maximum price of a single instance.
         """
         if instance_type is not None:
             pulumi.set(__self__, "instance_type", instance_type)
@@ -2100,7 +2897,7 @@ class NodePoolSpotPriceLimit(dict):
     @pulumi.getter(name="instanceType")
     def instance_type(self) -> Optional[str]:
         """
-        Spot instance type.
+        The type of the preemptible instance.
         """
         return pulumi.get(self, "instance_type")
 
@@ -2108,7 +2905,7 @@ class NodePoolSpotPriceLimit(dict):
     @pulumi.getter(name="priceLimit")
     def price_limit(self) -> Optional[str]:
         """
-        The maximum hourly price of the spot instance. A maximum of three decimal places are allowed.
+        The maximum price of a single instance.
         """
         return pulumi.get(self, "price_limit")
 
@@ -2155,18 +2952,83 @@ class NodePoolTaint(dict):
         return pulumi.get(self, "value")
 
 
+@pulumi.output_type
+class NodePoolTeeConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "teeEnable":
+            suggest = "tee_enable"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolTeeConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolTeeConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolTeeConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 tee_enable: Optional[bool] = None):
+        """
+        :param bool tee_enable: Specifies whether to enable confidential computing for the cluster.
+        """
+        if tee_enable is not None:
+            pulumi.set(__self__, "tee_enable", tee_enable)
+
+    @property
+    @pulumi.getter(name="teeEnable")
+    def tee_enable(self) -> Optional[bool]:
+        """
+        Specifies whether to enable confidential computing for the cluster.
+        """
+        return pulumi.get(self, "tee_enable")
+
+
 @pulumi.output_type
 class ServerlessKubernetesAddon(dict):
     def __init__(__self__, *,
                  config: Optional[str] = None,
                  disabled: Optional[bool] = None,
-                 name: Optional[str] = None):
+                 name: Optional[str] = None,
+                 version: Optional[str] = None):
         """
-        :param str config: The ACK add-on configurations.
+        :param str config: The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         :param bool disabled: Disables the automatic installation of a component. Default is `false`.
                
                The following example is the definition of addons block, The type of this field is list:
+               
+               ```
+               # install nginx ingress, conflict with ALB ingress
+               addons {
+               name = "nginx-ingress-controller"
+               # use internet
+               config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               # if use intranet, detail below.
+               # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+               }
+               # install ALB ingress, conflict with nginx ingress
+               addons {
+               name = "alb-ingress-controller"
+               }
+               # install metric server
+               addons {
+               name = "metrics-server"
+               }
+               # install knative
+               addons {
+               name = "knative"
+               }
+               # install prometheus
+               addons {
+               name = "arms-prometheus"
+               }
+               ```
         :param 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 str version: It specifies the version of the component.
         """
         if config is not None:
             pulumi.set(__self__, "config", config)
@@ -2174,12 +3036,14 @@ class ServerlessKubernetesAddon(dict):
             pulumi.set(__self__, "disabled", disabled)
         if name is not None:
             pulumi.set(__self__, "name", name)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
 
     @property
     @pulumi.getter
     def config(self) -> Optional[str]:
         """
-        The ACK add-on configurations.
+        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
         """
         return pulumi.get(self, "config")
 
@@ -2190,6 +3054,33 @@ class ServerlessKubernetesAddon(dict):
         Disables the automatic installation of a component. Default is `false`.
 
         The following example is the definition of addons block, The type of this field is list:
+
+        ```
+        # install nginx ingress, conflict with ALB ingress
+        addons {
+        name = "nginx-ingress-controller"
+        # use internet
+        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        # if use intranet, detail below.
+        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
+        }
+        # install ALB ingress, conflict with nginx ingress
+        addons {
+        name = "alb-ingress-controller"
+        }
+        # install metric server
+        addons {
+        name = "metrics-server"
+        }
+        # install knative
+        addons {
+        name = "knative"
+        }
+        # install prometheus
+        addons {
+        name = "arms-prometheus"
+        }
+        ```
         """
         return pulumi.get(self, "disabled")
 
@@ -2201,6 +3092,313 @@ class ServerlessKubernetesAddon(dict):
         """
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[str]:
+        """
+        It specifies the version of the component.
+        """
+        return pulumi.get(self, "version")
+
+
+@pulumi.output_type
+class ServerlessKubernetesDeleteOption(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "deleteMode":
+            suggest = "delete_mode"
+        elif key == "resourceType":
+            suggest = "resource_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServerlessKubernetesDeleteOption. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServerlessKubernetesDeleteOption.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServerlessKubernetesDeleteOption.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 delete_mode: Optional[str] = None,
+                 resource_type: Optional[str] = None):
+        """
+        :param str delete_mode: The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
+        :param 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[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")
+
+    @property
+    @pulumi.getter(name="resourceType")
+    def resource_type(self) -> Optional[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")
+
+
+@pulumi.output_type
+class ServerlessKubernetesMaintenanceWindow(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maintenanceTime":
+            suggest = "maintenance_time"
+        elif key == "weeklyPeriod":
+            suggest = "weekly_period"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServerlessKubernetesMaintenanceWindow. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServerlessKubernetesMaintenanceWindow.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServerlessKubernetesMaintenanceWindow.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 duration: Optional[str] = None,
+                 enable: Optional[bool] = None,
+                 maintenance_time: Optional[str] = None,
+                 weekly_period: Optional[str] = None):
+        """
+        :param str duration: The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
+        :param bool enable: Whether to open the maintenance window. The following parameters take effect only `enable = true`.
+        :param str maintenance_time: Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        :param 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[str]:
+        """
+        The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
+        """
+        return pulumi.get(self, "duration")
+
+    @property
+    @pulumi.getter
+    def enable(self) -> Optional[bool]:
+        """
+        Whether to open the maintenance window. The following parameters take effect only `enable = true`.
+        """
+        return pulumi.get(self, "enable")
+
+    @property
+    @pulumi.getter(name="maintenanceTime")
+    def maintenance_time(self) -> Optional[str]:
+        """
+        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        """
+        return pulumi.get(self, "maintenance_time")
+
+    @property
+    @pulumi.getter(name="weeklyPeriod")
+    def weekly_period(self) -> Optional[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")
+
+
+@pulumi.output_type
+class ServerlessKubernetesOperationPolicy(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clusterAutoUpgrade":
+            suggest = "cluster_auto_upgrade"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServerlessKubernetesOperationPolicy. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServerlessKubernetesOperationPolicy.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServerlessKubernetesOperationPolicy.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cluster_auto_upgrade: Optional['outputs.ServerlessKubernetesOperationPolicyClusterAutoUpgrade'] = None):
+        """
+        :param '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['outputs.ServerlessKubernetesOperationPolicyClusterAutoUpgrade']:
+        """
+        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
+        """
+        return pulumi.get(self, "cluster_auto_upgrade")
+
+
+@pulumi.output_type
+class ServerlessKubernetesOperationPolicyClusterAutoUpgrade(dict):
+    def __init__(__self__, *,
+                 channel: Optional[str] = None,
+                 enabled: Optional[bool] = None):
+        """
+        :param str channel: The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapid`.
+               
+               for example:
+               ```
+               operation_policy {
+               cluster_auto_upgrade {
+               enabled = true
+               channel = "stable"
+               }
+               }
+               ```
+        :param 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[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")
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Whether the RRSA feature has been enabled.
+        """
+        return pulumi.get(self, "enabled")
+
 
 @pulumi.output_type
 class ServerlessKubernetesRrsaMetadata(dict):
@@ -3131,29 +4329,42 @@ class GetKubernetesClustersClusterWorkerNodeResult(dict):
 @pulumi.output_type
 class GetKubernetesPermissionPermissionResult(dict):
     def __init__(__self__, *,
+                 is_owner: bool,
+                 is_ram_role: bool,
                  resource_id: str,
                  resource_type: str,
                  role_name: str,
-                 is_owner: Optional[bool] = None,
-                 is_ram_role: Optional[bool] = None,
-                 role_type: Optional[str] = None):
+                 role_type: str):
         """
+        :param bool is_owner: Indicates whether the permissions are granted to the cluster owner. Valid values `false`, `true`.
+        :param bool is_ram_role: Indicates whether the permissions are granted to the RAM role. Valid values `false`, `true`.
         :param str resource_id: The permission settings to manage ACK clusters.
         :param str resource_type: The authorization type. Valid values `cluster`, `namespace` and `console`.
         :param str role_name: The name of the predefined role. If a custom role is assigned, the value is the name of the assigined custom role.
-        :param bool is_owner: ndicates whether the permissions are granted to the cluster owner. Valid values `0`, `1`.
-        :param bool is_ram_role: Indicates whether the permissions are granted to the RAM role. Valid values `0`,`1`.
         :param str role_type: The predefined role. Valid values `admin`,`ops`,`dev`,`restricted` and `custom`.
         """
+        pulumi.set(__self__, "is_owner", is_owner)
+        pulumi.set(__self__, "is_ram_role", is_ram_role)
         pulumi.set(__self__, "resource_id", resource_id)
         pulumi.set(__self__, "resource_type", resource_type)
         pulumi.set(__self__, "role_name", role_name)
-        if is_owner is not None:
-            pulumi.set(__self__, "is_owner", is_owner)
-        if is_ram_role is not None:
-            pulumi.set(__self__, "is_ram_role", is_ram_role)
-        if role_type is not None:
-            pulumi.set(__self__, "role_type", role_type)
+        pulumi.set(__self__, "role_type", role_type)
+
+    @property
+    @pulumi.getter(name="isOwner")
+    def is_owner(self) -> bool:
+        """
+        Indicates whether the permissions are granted to the cluster owner. Valid values `false`, `true`.
+        """
+        return pulumi.get(self, "is_owner")
+
+    @property
+    @pulumi.getter(name="isRamRole")
+    def is_ram_role(self) -> bool:
+        """
+        Indicates whether the permissions are granted to the RAM role. Valid values `false`, `true`.
+        """
+        return pulumi.get(self, "is_ram_role")
 
     @property
     @pulumi.getter(name="resourceId")
@@ -3179,25 +4390,9 @@ class GetKubernetesPermissionPermissionResult(dict):
         """
         return pulumi.get(self, "role_name")
 
-    @property
-    @pulumi.getter(name="isOwner")
-    def is_owner(self) -> Optional[bool]:
-        """
-        ndicates whether the permissions are granted to the cluster owner. Valid values `0`, `1`.
-        """
-        return pulumi.get(self, "is_owner")
-
-    @property
-    @pulumi.getter(name="isRamRole")
-    def is_ram_role(self) -> Optional[bool]:
-        """
-        Indicates whether the permissions are granted to the RAM role. Valid values `0`,`1`.
-        """
-        return pulumi.get(self, "is_ram_role")
-
     @property
     @pulumi.getter(name="roleType")
-    def role_type(self) -> Optional[str]:
+    def role_type(self) -> str:
         """
         The predefined role. Valid values `admin`,`ops`,`dev`,`restricted` and `custom`.
         """
@@ -4188,7 +5383,7 @@ class GetServerlessKubernetesClustersClusterResult(dict):
                  name: str,
                  nat_gateway_id: str,
                  security_group_id: str,
-                 tags: Mapping[str, Any],
+                 tags: Mapping[str, str],
                  vpc_id: str,
                  vswitch_id: str):
         """
@@ -4199,7 +5394,7 @@ class GetServerlessKubernetesClustersClusterResult(dict):
         :param str nat_gateway_id: The ID of nat gateway used to launch kubernetes cluster.
         :param str security_group_id: The ID of security group where the current cluster  is located.
         :param str vpc_id: The ID of VPC where the current cluster is located.
-        :param str vswitch_id: The ID of VSwitch where the current cluster is located.
+        :param str vswitch_id: The ID of vSwitch where the current cluster is located.
         """
         pulumi.set(__self__, "connections", connections)
         pulumi.set(__self__, "deletion_protection", deletion_protection)
@@ -4267,7 +5462,7 @@ class GetServerlessKubernetesClustersClusterResult(dict):
 
     @property
     @pulumi.getter
-    def tags(self) -> Mapping[str, Any]:
+    def tags(self) -> Mapping[str, str]:
         return pulumi.get(self, "tags")
 
     @property
@@ -4282,7 +5477,7 @@ class GetServerlessKubernetesClustersClusterResult(dict):
     @pulumi.getter(name="vswitchId")
     def vswitch_id(self) -> str:
         """
-        The ID of VSwitch where the current cluster is located.
+        The ID of vSwitch where the current cluster is located.
         """
         return pulumi.get(self, "vswitch_id")