pulumi-alicloud 3.53.0a1713354491__py3-none-any.whl → 3.73.0a1736850863__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,13 +29,17 @@ __all__ = [
     'KubernetesAutoscalerNodepool',
     'KubernetesCertificateAuthority',
     'KubernetesConnections',
+    'KubernetesDeleteOption',
     'KubernetesMasterNode',
     'KubernetesPermissionPermission',
     'KubernetesRuntime',
     'ManagedKubernetesAddon',
     'ManagedKubernetesCertificateAuthority',
     'ManagedKubernetesConnections',
+    'ManagedKubernetesDeleteOption',
     'ManagedKubernetesMaintenanceWindow',
+    'ManagedKubernetesOperationPolicy',
+    'ManagedKubernetesOperationPolicyClusterAutoUpgrade',
     'ManagedKubernetesRrsaMetadata',
     'NodePoolDataDisk',
     'NodePoolKubeletConfiguration',
@@ -46,6 +55,10 @@ __all__ = [
     'NodePoolTaint',
     'NodePoolTeeConfig',
     'ServerlessKubernetesAddon',
+    'ServerlessKubernetesDeleteOption',
+    'ServerlessKubernetesMaintenanceWindow',
+    'ServerlessKubernetesOperationPolicy',
+    'ServerlessKubernetesOperationPolicyClusterAutoUpgrade',
     'ServerlessKubernetesRrsaMetadata',
     'SwarmNode',
     'GetClusterCredentialCertificateAuthorityResult',
@@ -432,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)
@@ -444,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")
 
@@ -452,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")
 
@@ -921,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
@@ -1014,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, When `role_type` value is `all-clusters`, the value of `role_type` must be null.
+        :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` and `all-clusters`.
-        :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 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.
         """
@@ -1035,7 +1174,7 @@ class KubernetesPermissionPermission(dict):
     @pulumi.getter
     def cluster(self) -> str:
         """
-        The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `role_type` must be null.
+        The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `cluster` must be `""`.
         """
         return pulumi.get(self, "cluster")
 
@@ -1059,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")
 
@@ -1086,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)
@@ -1098,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")
 
@@ -1106,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")
 
@@ -1328,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
@@ -1350,34 +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:
                ```
                maintenance_window {
                enable            = true
-               maintenance_time  = "01:00:00Z"
+               maintenance_time  = "2024-10-15T12:31:00.000+08:00"
                duration          = "3h"
                weekly_period     = "Monday,Friday"
                }
                ```
         """
-        pulumi.set(__self__, "duration", duration)
-        pulumi.set(__self__, "enable", enable)
-        pulumi.set(__self__, "maintenance_time", maintenance_time)
-        pulumi.set(__self__, "weekly_period", weekly_period)
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+        if enable is not None:
+            pulumi.set(__self__, "enable", enable)
+        if maintenance_time is not None:
+            pulumi.set(__self__, "maintenance_time", maintenance_time)
+        if weekly_period is not None:
+            pulumi.set(__self__, "weekly_period", weekly_period)
 
     @property
     @pulumi.getter
-    def duration(self) -> str:
+    def duration(self) -> Optional[str]:
         """
         The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
         """
@@ -1385,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`.
         """
@@ -1393,15 +1662,15 @@ 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.
 
@@ -1409,7 +1678,7 @@ class ManagedKubernetesMaintenanceWindow(dict):
         ```
         maintenance_window {
         enable            = true
-        maintenance_time  = "01:00:00Z"
+        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
         duration          = "3h"
         weekly_period     = "Monday,Friday"
         }
@@ -1418,6 +1687,93 @@ class ManagedKubernetesMaintenanceWindow(dict):
         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
@@ -1499,12 +1855,18 @@ 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":
@@ -1524,30 +1886,38 @@ 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 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 length is 2~128 English or Chinese characters. It must start with an uppercase or lowr letter or a Chinese character and cannot start with http:// or https. Can contain numbers, colons (:), underscores (_), or dashes (-).
+        :param 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:
@@ -1558,8 +1928,12 @@ class NodePoolDataDisk(dict):
             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:
@@ -1571,6 +1945,14 @@ class NodePoolDataDisk(dict):
         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]:
@@ -1611,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]:
@@ -1619,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 length is 2~128 English or Chinese characters. It must start with an uppercase or lowr letter or a Chinese character and cannot start with http:// or https. Can contain numbers, colons (:), underscores (_), or dashes (-).
+        The 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")
 
@@ -1722,19 +2120,19 @@ class NodePoolKubeletConfiguration(dict):
                  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.
@@ -1742,19 +2140,19 @@ class NodePoolKubeletConfiguration(dict):
         :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)
@@ -1845,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"}`.
         """
@@ -1853,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"}`.
         """
@@ -1861,7 +2259,7 @@ 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"}`.
         """
@@ -1893,7 +2291,7 @@ 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.
         """
@@ -1941,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.
         """
@@ -2121,24 +2519,20 @@ class NodePoolManagement(dict):
 
     @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.
         """
-        warnings.warn("""Field 'surge' has been deprecated from provider version 1.219.0. Number of additional nodes. You have to specify one of surge, surge_percentage.""", DeprecationWarning)
-        pulumi.log.warn("""surge is deprecated: Field 'surge' has been deprecated from provider version 1.219.0. Number of additional nodes. You have to specify one of surge, surge_percentage.""")
-
         return pulumi.get(self, "surge")
 
     @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.
         """
-        warnings.warn("""Field 'surge_percentage' has been deprecated from provider version 1.219.0. Proportion of additional nodes. You have to specify one of surge, surge_percentage.""", DeprecationWarning)
-        pulumi.log.warn("""surge_percentage is deprecated: Field 'surge_percentage' has been deprecated from provider version 1.219.0. Proportion of additional nodes. You have to specify one of surge, surge_percentage.""")
-
         return pulumi.get(self, "surge_percentage")
 
 
@@ -2387,7 +2781,7 @@ class NodePoolScalingConfig(dict):
                  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. It works if `is_bond_eip=true`. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. Conflict with `internet_charge_type`, EIP and public network IP can only choose one.
+        :param 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`.
@@ -2421,7 +2815,7 @@ class NodePoolScalingConfig(dict):
     @pulumi.getter(name="eipInternetChargeType")
     def eip_internet_charge_type(self) -> Optional[str]:
         """
-        EIP billing type. It works if `is_bond_eip=true`. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. Conflict with `internet_charge_type`, EIP and public network IP can only choose one.
+        EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. It works if `is_bond_eip=true`, conflict with `internet_charge_type`. EIP and public network IP can only choose one.
         """
         return pulumi.get(self, "eip_internet_charge_type")
 
@@ -2599,7 +2993,8 @@ 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. For more config information, see cs_kubernetes_addon_metadata.
         :param bool disabled: Disables the automatic installation of a component. Default is `false`.
@@ -2607,7 +3002,7 @@ class ServerlessKubernetesAddon(dict):
                The following example is the definition of addons block, The type of this field is list:
                
                ```
-               # install nginx ingress, conflict with SLB ingress
+               # install nginx ingress, conflict with ALB ingress
                addons {
                name = "nginx-ingress-controller"
                # use internet
@@ -2615,7 +3010,7 @@ class ServerlessKubernetesAddon(dict):
                # if use intranet, detail below.
                # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
                }
-               # install SLB ingress, conflict with nginx ingress
+               # install ALB ingress, conflict with nginx ingress
                addons {
                name = "alb-ingress-controller"
                }
@@ -2630,11 +3025,10 @@ class ServerlessKubernetesAddon(dict):
                # install prometheus
                addons {
                name = "arms-prometheus"
-               # prometheus also provides managed version, specify with name `managed-arms-prometheus` for professional serverless clusters
-               # name = "managed-arms-prometheus"
                }
                ```
         :param 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)
@@ -2642,6 +3036,8 @@ 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
@@ -2660,7 +3056,7 @@ class ServerlessKubernetesAddon(dict):
         The following example is the definition of addons block, The type of this field is list:
 
         ```
-        # install nginx ingress, conflict with SLB ingress
+        # install nginx ingress, conflict with ALB ingress
         addons {
         name = "nginx-ingress-controller"
         # use internet
@@ -2668,7 +3064,7 @@ class ServerlessKubernetesAddon(dict):
         # if use intranet, detail below.
         # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
         }
-        # install SLB ingress, conflict with nginx ingress
+        # install ALB ingress, conflict with nginx ingress
         addons {
         name = "alb-ingress-controller"
         }
@@ -2683,8 +3079,6 @@ class ServerlessKubernetesAddon(dict):
         # install prometheus
         addons {
         name = "arms-prometheus"
-        # prometheus also provides managed version, specify with name `managed-arms-prometheus` for professional serverless clusters
-        # name = "managed-arms-prometheus"
         }
         ```
         """
@@ -2698,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):
@@ -4682,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):
         """
@@ -4693,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)
@@ -4761,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
@@ -4776,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")