pulumi-alicloud 3.64.0__py3-none-any.whl → 3.64.0a1727846271__py3-none-any.whl

pulumi_alicloud/cs/_inputs.py

@@ -4,120 +4,54 @@
 
 import copy
 import warnings
-import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
-if sys.version_info >= (3, 11):
-    from typing import NotRequired, TypedDict, TypeAlias
-else:
-    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'ApplicationServiceArgs',
-    'ApplicationServiceArgsDict',
     'ClusterNodeArgs',
-    'ClusterNodeArgsDict',
     'EdgeKubernetesAddonArgs',
-    'EdgeKubernetesAddonArgsDict',
     'EdgeKubernetesCertificateAuthorityArgs',
-    'EdgeKubernetesCertificateAuthorityArgsDict',
     'EdgeKubernetesConnectionsArgs',
-    'EdgeKubernetesConnectionsArgsDict',
     'EdgeKubernetesLogConfigArgs',
-    'EdgeKubernetesLogConfigArgsDict',
     'EdgeKubernetesRuntimeArgs',
-    'EdgeKubernetesRuntimeArgsDict',
     'EdgeKubernetesWorkerDataDiskArgs',
-    'EdgeKubernetesWorkerDataDiskArgsDict',
     'EdgeKubernetesWorkerNodeArgs',
-    'EdgeKubernetesWorkerNodeArgsDict',
     'KubernetesAddonArgs',
-    'KubernetesAddonArgsDict',
     'KubernetesAutoscalerNodepoolArgs',
-    'KubernetesAutoscalerNodepoolArgsDict',
     'KubernetesCertificateAuthorityArgs',
-    'KubernetesCertificateAuthorityArgsDict',
     'KubernetesConnectionsArgs',
-    'KubernetesConnectionsArgsDict',
     'KubernetesDeleteOptionArgs',
-    'KubernetesDeleteOptionArgsDict',
     'KubernetesMasterNodeArgs',
-    'KubernetesMasterNodeArgsDict',
     'KubernetesPermissionPermissionArgs',
-    'KubernetesPermissionPermissionArgsDict',
     'KubernetesRuntimeArgs',
-    'KubernetesRuntimeArgsDict',
     'ManagedKubernetesAddonArgs',
-    'ManagedKubernetesAddonArgsDict',
     'ManagedKubernetesCertificateAuthorityArgs',
-    'ManagedKubernetesCertificateAuthorityArgsDict',
     'ManagedKubernetesConnectionsArgs',
-    'ManagedKubernetesConnectionsArgsDict',
     'ManagedKubernetesDeleteOptionArgs',
-    'ManagedKubernetesDeleteOptionArgsDict',
     'ManagedKubernetesMaintenanceWindowArgs',
-    'ManagedKubernetesMaintenanceWindowArgsDict',
-    'ManagedKubernetesOperationPolicyArgs',
-    'ManagedKubernetesOperationPolicyArgsDict',
-    'ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs',
-    'ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict',
     'ManagedKubernetesRrsaMetadataArgs',
-    'ManagedKubernetesRrsaMetadataArgsDict',
     'NodePoolDataDiskArgs',
-    'NodePoolDataDiskArgsDict',
     'NodePoolKubeletConfigurationArgs',
-    'NodePoolKubeletConfigurationArgsDict',
     'NodePoolLabelArgs',
-    'NodePoolLabelArgsDict',
     'NodePoolManagementArgs',
-    'NodePoolManagementArgsDict',
     'NodePoolManagementAutoRepairPolicyArgs',
-    'NodePoolManagementAutoRepairPolicyArgsDict',
     'NodePoolManagementAutoUpgradePolicyArgs',
-    'NodePoolManagementAutoUpgradePolicyArgsDict',
     'NodePoolManagementAutoVulFixPolicyArgs',
-    'NodePoolManagementAutoVulFixPolicyArgsDict',
     'NodePoolPrivatePoolOptionsArgs',
-    'NodePoolPrivatePoolOptionsArgsDict',
     'NodePoolRollingPolicyArgs',
-    'NodePoolRollingPolicyArgsDict',
     'NodePoolScalingConfigArgs',
-    'NodePoolScalingConfigArgsDict',
     'NodePoolSpotPriceLimitArgs',
-    'NodePoolSpotPriceLimitArgsDict',
     'NodePoolTaintArgs',
-    'NodePoolTaintArgsDict',
     'NodePoolTeeConfigArgs',
-    'NodePoolTeeConfigArgsDict',
     'ServerlessKubernetesAddonArgs',
-    'ServerlessKubernetesAddonArgsDict',
     'ServerlessKubernetesDeleteOptionArgs',
-    'ServerlessKubernetesDeleteOptionArgsDict',
-    'ServerlessKubernetesMaintenanceWindowArgs',
-    'ServerlessKubernetesMaintenanceWindowArgsDict',
-    'ServerlessKubernetesOperationPolicyArgs',
-    'ServerlessKubernetesOperationPolicyArgsDict',
-    'ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs',
-    'ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict',
     'ServerlessKubernetesRrsaMetadataArgs',
-    'ServerlessKubernetesRrsaMetadataArgsDict',
     'SwarmNodeArgs',
-    'SwarmNodeArgsDict',
 ]
 
-MYPY = False
-
-if not MYPY:
-    class ApplicationServiceArgsDict(TypedDict):
-        id: NotRequired[pulumi.Input[str]]
-        name: NotRequired[pulumi.Input[str]]
-        status: NotRequired[pulumi.Input[str]]
-        version: NotRequired[pulumi.Input[str]]
-elif False:
-    ApplicationServiceArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ApplicationServiceArgs:
     def __init__(__self__, *,
@@ -171,16 +105,6 @@ class ApplicationServiceArgs:
         pulumi.set(self, "version", value)
 
 
-if not MYPY:
-    class ClusterNodeArgsDict(TypedDict):
-        eip: NotRequired[pulumi.Input[str]]
-        id: NotRequired[pulumi.Input[str]]
-        name: NotRequired[pulumi.Input[str]]
-        private_ip: NotRequired[pulumi.Input[str]]
-        status: NotRequired[pulumi.Input[str]]
-elif False:
-    ClusterNodeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ClusterNodeArgs:
     def __init__(__self__, *,
@@ -246,40 +170,6 @@ class ClusterNodeArgs:
         pulumi.set(self, "status", value)
 
 
-if not MYPY:
-    class EdgeKubernetesAddonArgsDict(TypedDict):
-        config: NotRequired[pulumi.Input[str]]
-        """
-        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
-        """
-        disabled: NotRequired[pulumi.Input[bool]]
-        """
-        Disables the automatic installation of a component. Default is `false`.
-
-        The following example is the definition of addons block, The type of this field is list:
-
-        ```
-        # install nginx ingress, conflict with SLB ingress
-        addons {
-        name = "nginx-ingress-controller"
-        # use internet
-        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
-        # if use intranet, detail below.
-        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
-        }
-        ```
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
-        """
-        version: NotRequired[pulumi.Input[str]]
-        """
-        It specifies the version of the component.
-        """
-elif False:
-    EdgeKubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeKubernetesAddonArgs:
     def __init__(__self__, *,
@@ -377,23 +267,6 @@ class EdgeKubernetesAddonArgs:
         pulumi.set(self, "version", value)
 
 
-if not MYPY:
-    class EdgeKubernetesCertificateAuthorityArgsDict(TypedDict):
-        client_cert: NotRequired[pulumi.Input[str]]
-        """
-        The path of client certificate, like `~/.kube/client-cert.pem`.
-        """
-        client_key: NotRequired[pulumi.Input[str]]
-        """
-        The path of client key, like `~/.kube/client-key.pem`.
-        """
-        cluster_cert: NotRequired[pulumi.Input[str]]
-        """
-        The base64 encoded cluster certificate data required to communicate with your cluster. Add this to the certificate-authority-data section of the kubeconfig file for your cluster.
-        """
-elif False:
-    EdgeKubernetesCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeKubernetesCertificateAuthorityArgs:
     def __init__(__self__, *,
@@ -449,27 +322,6 @@ class EdgeKubernetesCertificateAuthorityArgs:
         pulumi.set(self, "cluster_cert", value)
 
 
-if not MYPY:
-    class EdgeKubernetesConnectionsArgsDict(TypedDict):
-        api_server_internet: NotRequired[pulumi.Input[str]]
-        """
-        API Server Internet endpoint.
-        """
-        api_server_intranet: NotRequired[pulumi.Input[str]]
-        """
-        API Server Intranet endpoint.
-        """
-        master_public_ip: NotRequired[pulumi.Input[str]]
-        """
-        Master node SSH IP address.
-        """
-        service_domain: NotRequired[pulumi.Input[str]]
-        """
-        Service Access Domain.
-        """
-elif False:
-    EdgeKubernetesConnectionsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeKubernetesConnectionsArgs:
     def __init__(__self__, *,
@@ -541,19 +393,6 @@ class EdgeKubernetesConnectionsArgs:
         pulumi.set(self, "service_domain", value)
 
 
-if not MYPY:
-    class EdgeKubernetesLogConfigArgsDict(TypedDict):
-        type: pulumi.Input[str]
-        """
-        Type of collecting logs, only `SLS` are supported currently.
-        """
-        project: NotRequired[pulumi.Input[str]]
-        """
-        Log Service project name, cluster logs will output to this project.
-        """
-elif False:
-    EdgeKubernetesLogConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeKubernetesLogConfigArgs:
     def __init__(__self__, *,
@@ -592,28 +431,6 @@ class EdgeKubernetesLogConfigArgs:
         pulumi.set(self, "project", value)
 
 
-if not MYPY:
-    class EdgeKubernetesRuntimeArgsDict(TypedDict):
-        name: NotRequired[pulumi.Input[str]]
-        """
-        The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
-        """
-        version: NotRequired[pulumi.Input[str]]
-        """
-        The version of the runtime.
-
-        The following example is the definition of runtime block:
-
-        ```
-        runtime = {
-        name = "containerd"
-        version = "1.6.28"
-        }
-        ```
-        """
-elif False:
-    EdgeKubernetesRuntimeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeKubernetesRuntimeArgs:
     def __init__(__self__, *,
@@ -671,47 +488,6 @@ class EdgeKubernetesRuntimeArgs:
         pulumi.set(self, "version", value)
 
 
-if not MYPY:
-    class EdgeKubernetesWorkerDataDiskArgsDict(TypedDict):
-        auto_snapshot_policy_id: NotRequired[pulumi.Input[str]]
-        """
-        Worker node data disk auto snapshot policy.
-        """
-        category: NotRequired[pulumi.Input[str]]
-        """
-        The type of the data disks. Valid values: `cloud`, `cloud_efficiency`, `cloud_ssd` and `cloud_essd`. Default to `cloud_efficiency`.
-        """
-        device: NotRequired[pulumi.Input[str]]
-        """
-        The device of the data disks.
-        """
-        encrypted: NotRequired[pulumi.Input[str]]
-        """
-        Specifies whether to encrypt data disks. Valid values: true and false. Default is `false`.
-        """
-        kms_key_id: NotRequired[pulumi.Input[str]]
-        """
-        The id of the kms key.
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        The name of the data disks.
-        """
-        performance_level: NotRequired[pulumi.Input[str]]
-        """
-        Worker node data disk performance level, when `category` values `cloud_essd`, the optional values are `PL0`, `PL1`, `PL2` or `PL3`, but the specific performance level is related to the disk capacity. For more information, see [Enhanced SSDs](https://www.alibabacloud.com/help/doc-detail/122389.htm). Default is `PL1`.
-        """
-        size: NotRequired[pulumi.Input[str]]
-        """
-        The size of a data disk, at least 40. Unit: GiB.
-        """
-        snapshot_id: NotRequired[pulumi.Input[str]]
-        """
-        The id of snapshot.
-        """
-elif False:
-    EdgeKubernetesWorkerDataDiskArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeKubernetesWorkerDataDiskArgs:
     def __init__(__self__, *,
@@ -863,23 +639,6 @@ class EdgeKubernetesWorkerDataDiskArgs:
         pulumi.set(self, "snapshot_id", value)
 
 
-if not MYPY:
-    class EdgeKubernetesWorkerNodeArgsDict(TypedDict):
-        id: NotRequired[pulumi.Input[str]]
-        """
-        ID of the node.
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        The kubernetes cluster's name. It is unique in one Alicloud account.
-        """
-        private_ip: NotRequired[pulumi.Input[str]]
-        """
-        The private IP address of node.
-        """
-elif False:
-    EdgeKubernetesWorkerNodeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class EdgeKubernetesWorkerNodeArgs:
     def __init__(__self__, *,
@@ -935,40 +694,6 @@ class EdgeKubernetesWorkerNodeArgs:
         pulumi.set(self, "private_ip", value)
 
 
-if not MYPY:
-    class KubernetesAddonArgsDict(TypedDict):
-        config: NotRequired[pulumi.Input[str]]
-        """
-        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
-        """
-        disabled: NotRequired[pulumi.Input[bool]]
-        """
-        Disables the automatic installation of a component. Default is `false`.
-
-        The following example is the definition of addons block, The type of this field is list:
-
-        ```
-        # install nginx ingress, conflict with SLB ingress
-        addons {
-        name = "nginx-ingress-controller"
-        # use internet
-        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
-        # if use intranet, detail below.
-        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
-        }
-        ```
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
-        """
-        version: NotRequired[pulumi.Input[str]]
-        """
-        The version of the component.
-        """
-elif False:
-    KubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesAddonArgs:
     def __init__(__self__, *,
@@ -1066,23 +791,6 @@ class KubernetesAddonArgs:
         pulumi.set(self, "version", value)
 
 
-if not MYPY:
-    class KubernetesAutoscalerNodepoolArgsDict(TypedDict):
-        id: NotRequired[pulumi.Input[str]]
-        """
-        The scaling group id of the groups configured for cluster-autoscaler.
-        """
-        labels: NotRequired[pulumi.Input[str]]
-        """
-        The labels for the nodes in scaling group.
-        """
-        taints: NotRequired[pulumi.Input[str]]
-        """
-        The taints for the nodes in scaling group.
-        """
-elif False:
-    KubernetesAutoscalerNodepoolArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesAutoscalerNodepoolArgs:
     def __init__(__self__, *,
@@ -1138,23 +846,6 @@ class KubernetesAutoscalerNodepoolArgs:
         pulumi.set(self, "taints", value)
 
 
-if not MYPY:
-    class KubernetesCertificateAuthorityArgsDict(TypedDict):
-        client_cert: NotRequired[pulumi.Input[str]]
-        """
-        The path of client certificate, like `~/.kube/client-cert.pem`.
-        """
-        client_key: NotRequired[pulumi.Input[str]]
-        """
-        The path of client key, like `~/.kube/client-key.pem`.
-        """
-        cluster_cert: NotRequired[pulumi.Input[str]]
-        """
-        The base64 encoded cluster certificate data required to communicate with your cluster. Add this to the certificate-authority-data section of the kubeconfig file for your cluster.
-        """
-elif False:
-    KubernetesCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesCertificateAuthorityArgs:
     def __init__(__self__, *,
@@ -1210,27 +901,6 @@ class KubernetesCertificateAuthorityArgs:
         pulumi.set(self, "cluster_cert", value)
 
 
-if not MYPY:
-    class KubernetesConnectionsArgsDict(TypedDict):
-        api_server_internet: NotRequired[pulumi.Input[str]]
-        """
-        API Server Internet endpoint.
-        """
-        api_server_intranet: NotRequired[pulumi.Input[str]]
-        """
-        API Server Intranet endpoint.
-        """
-        master_public_ip: NotRequired[pulumi.Input[str]]
-        """
-        Master node SSH IP address.
-        """
-        service_domain: NotRequired[pulumi.Input[str]]
-        """
-        Service Access Domain.
-        """
-elif False:
-    KubernetesConnectionsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesConnectionsArgs:
     def __init__(__self__, *,
@@ -1302,48 +972,6 @@ class KubernetesConnectionsArgs:
         pulumi.set(self, "service_domain", value)
 
 
-if not MYPY:
-    class KubernetesDeleteOptionArgsDict(TypedDict):
-        delete_mode: NotRequired[pulumi.Input[str]]
-        """
-        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
-        """
-        resource_type: NotRequired[pulumi.Input[str]]
-        """
-        The type of resources that are created by cluster. Valid values:
-        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
-        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
-        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
-        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
-
-        ```
-        ...
-        // Specify delete_options as below when deleting cluster
-        // delete SLB resources created by the Nginx Ingress Service
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLB"
-        }
-        // delete ALB resources created by the ALB Ingress Controller
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "ALB"
-        }
-        // delete SLS Project used by the cluster logging feature
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLS_Data"
-        }
-        // delete SLS Project used for the managed cluster control plane logs
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLS_ControlPlane"
-        }
-        ```
-        """
-elif False:
-    KubernetesDeleteOptionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesDeleteOptionArgs:
     def __init__(__self__, *,
@@ -1441,23 +1069,6 @@ class KubernetesDeleteOptionArgs:
         pulumi.set(self, "resource_type", value)
 
 
-if not MYPY:
-    class KubernetesMasterNodeArgsDict(TypedDict):
-        id: NotRequired[pulumi.Input[str]]
-        """
-        ID of the node.
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        The kubernetes cluster's name. It is unique in one Alicloud account.
-        """
-        private_ip: NotRequired[pulumi.Input[str]]
-        """
-        The private IP address of node.
-        """
-elif False:
-    KubernetesMasterNodeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesMasterNodeArgs:
     def __init__(__self__, *,
@@ -1513,35 +1124,6 @@ class KubernetesMasterNodeArgs:
         pulumi.set(self, "private_ip", value)
 
 
-if not MYPY:
-    class KubernetesPermissionPermissionArgsDict(TypedDict):
-        cluster: pulumi.Input[str]
-        """
-        The ID of the cluster that you want to manage, When `role_type` value is `all-clusters`, the value of `cluster` must be `""`.
-        """
-        role_name: pulumi.Input[str]
-        """
-        Specifies the predefined role that you want to assign. Valid values `admin`, `ops`, `dev`, `restricted` and the custom cluster roles.
-        """
-        role_type: pulumi.Input[str]
-        """
-        The authorization type. Valid values `cluster`, `namespace` and `all-clusters`.
-        """
-        is_custom: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to perform a custom authorization. To perform a custom authorization, the value of `is_custom` must be `true`, and set `role_name` to a custom cluster role.
-        """
-        is_ram_role: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether the permissions are granted to a RAM role. When `uid` is ram role id, the value of `is_ram_role` must be `true`.
-        """
-        namespace: NotRequired[pulumi.Input[str]]
-        """
-        The namespace to which the permissions are scoped. This parameter is required only if you set role_type to namespace.
-        """
-elif False:
-    KubernetesPermissionPermissionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesPermissionPermissionArgs:
     def __init__(__self__, *,
@@ -1642,28 +1224,6 @@ class KubernetesPermissionPermissionArgs:
         pulumi.set(self, "namespace", value)
 
 
-if not MYPY:
-    class KubernetesRuntimeArgsDict(TypedDict):
-        name: NotRequired[pulumi.Input[str]]
-        """
-        The name of the runtime. Supported runtimes can be queried by data source alicloud_cs_kubernetes_version.
-        """
-        version: NotRequired[pulumi.Input[str]]
-        """
-        The version of the runtime.
-
-        The following example is the definition of runtime block:
-
-        ```
-        runtime = {
-        name = "containerd"
-        version = "1.6.28"
-        }
-        ```
-        """
-elif False:
-    KubernetesRuntimeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class KubernetesRuntimeArgs:
     def __init__(__self__, *,
@@ -1721,37 +1281,6 @@ class KubernetesRuntimeArgs:
         pulumi.set(self, "version", value)
 
 
-if not MYPY:
-    class ManagedKubernetesAddonArgsDict(TypedDict):
-        config: NotRequired[pulumi.Input[str]]
-        """
-        If this parameter is left empty, no configurations are required. For more config information, see cs_kubernetes_addon_metadata.
-        """
-        disabled: NotRequired[pulumi.Input[bool]]
-        """
-        It specifies whether to disable automatic installation. 
-
-        It is a new field since 1.75.0. You can specific network plugin, log component,ingress component and so on.
-
-        You can get more information about addons on ACK web console. When you create a ACK cluster. You can get openapi-spec before creating the cluster on submission page.
-
-        `logtail-ds` - You can specify `IngressDashboardEnabled` and `sls_project_name` in config. If you switch on `IngressDashboardEnabled` and `sls_project_name`,then logtail-ds would use `sls_project_name` as default log store.
-
-        `nginx-ingress-controller` - You can specific `IngressSlbNetworkType` in config. Options: internet|intranet.
-
-        The `main.tf`:
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        This parameter specifies the name of the component.
-        """
-        version: NotRequired[pulumi.Input[str]]
-        """
-        It specifies the version of the component.
-        """
-elif False:
-    ManagedKubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ManagedKubernetesAddonArgs:
     def __init__(__self__, *,
@@ -1843,23 +1372,6 @@ class ManagedKubernetesAddonArgs:
         pulumi.set(self, "version", value)
 
 
-if not MYPY:
-    class ManagedKubernetesCertificateAuthorityArgsDict(TypedDict):
-        client_cert: NotRequired[pulumi.Input[str]]
-        """
-        The path of client certificate, like `~/.kube/client-cert.pem`.
-        """
-        client_key: NotRequired[pulumi.Input[str]]
-        """
-        The path of client key, like `~/.kube/client-key.pem`.
-        """
-        cluster_cert: NotRequired[pulumi.Input[str]]
-        """
-        The base64 encoded cluster certificate data required to communicate with your cluster. Add this to the certificate-authority-data section of the kubeconfig file for your cluster.
-        """
-elif False:
-    ManagedKubernetesCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ManagedKubernetesCertificateAuthorityArgs:
     def __init__(__self__, *,
@@ -1915,27 +1427,6 @@ class ManagedKubernetesCertificateAuthorityArgs:
         pulumi.set(self, "cluster_cert", value)
 
 
-if not MYPY:
-    class ManagedKubernetesConnectionsArgsDict(TypedDict):
-        api_server_internet: NotRequired[pulumi.Input[str]]
-        """
-        API Server Internet endpoint.
-        """
-        api_server_intranet: NotRequired[pulumi.Input[str]]
-        """
-        API Server Intranet endpoint.
-        """
-        master_public_ip: NotRequired[pulumi.Input[str]]
-        """
-        Master node SSH IP address.
-        """
-        service_domain: NotRequired[pulumi.Input[str]]
-        """
-        Service Access Domain.
-        """
-elif False:
-    ManagedKubernetesConnectionsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ManagedKubernetesConnectionsArgs:
     def __init__(__self__, *,
@@ -2007,48 +1498,6 @@ class ManagedKubernetesConnectionsArgs:
         pulumi.set(self, "service_domain", value)
 
 
-if not MYPY:
-    class ManagedKubernetesDeleteOptionArgsDict(TypedDict):
-        delete_mode: NotRequired[pulumi.Input[str]]
-        """
-        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
-        """
-        resource_type: NotRequired[pulumi.Input[str]]
-        """
-        The type of resources that are created by cluster. Valid values:
-        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
-        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
-        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
-        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
-
-        ```
-        ...
-        // Specify delete_options as below when deleting cluster
-        // delete SLB resources created by the Nginx Ingress Service
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLB"
-        }
-        // delete ALB resources created by the ALB Ingress Controller
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "ALB"
-        }
-        // delete SLS Project used by the cluster logging feature
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLS_Data"
-        }
-        // delete SLS Project used for the managed cluster control plane logs
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLS_ControlPlane"
-        }
-        ```
-        """
-elif False:
-    ManagedKubernetesDeleteOptionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ManagedKubernetesDeleteOptionArgs:
     def __init__(__self__, *,
@@ -2146,108 +1595,73 @@ class ManagedKubernetesDeleteOptionArgs:
         pulumi.set(self, "resource_type", value)
 
 
-if not MYPY:
-    class ManagedKubernetesMaintenanceWindowArgsDict(TypedDict):
-        duration: NotRequired[pulumi.Input[str]]
-        """
-        The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
-        """
-        enable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to open the maintenance window. The following parameters take effect only `enable = true`.
-        """
-        maintenance_time: NotRequired[pulumi.Input[str]]
-        """
-        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
-        """
-        weekly_period: NotRequired[pulumi.Input[str]]
-        """
-        Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
-
-        for example:
-        ```
-        maintenance_window {
-        enable            = true
-        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
-        duration          = "3h"
-        weekly_period     = "Monday,Friday"
-        }
-        ```
-        """
-elif False:
-    ManagedKubernetesMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ManagedKubernetesMaintenanceWindowArgs:
     def __init__(__self__, *,
-                 duration: Optional[pulumi.Input[str]] = None,
-                 enable: Optional[pulumi.Input[bool]] = None,
-                 maintenance_time: Optional[pulumi.Input[str]] = None,
-                 weekly_period: Optional[pulumi.Input[str]] = None):
+                 duration: pulumi.Input[str],
+                 enable: pulumi.Input[bool],
+                 maintenance_time: pulumi.Input[str],
+                 weekly_period: pulumi.Input[str]):
         """
         :param pulumi.Input[str] duration: The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
         :param pulumi.Input[bool] enable: Whether to open the maintenance window. The following parameters take effect only `enable = true`.
-        :param pulumi.Input[str] maintenance_time: Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        :param pulumi.Input[str] maintenance_time: Initial maintenance time, For example:"03:00:00Z".
         :param pulumi.Input[str] weekly_period: Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
                
                for example:
                ```
                maintenance_window {
                enable            = true
-               maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+               maintenance_time  = "01:00:00Z"
                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)
+        pulumi.set(__self__, "duration", duration)
+        pulumi.set(__self__, "enable", enable)
+        pulumi.set(__self__, "maintenance_time", maintenance_time)
+        pulumi.set(__self__, "weekly_period", weekly_period)
 
     @property
     @pulumi.getter
-    def duration(self) -> Optional[pulumi.Input[str]]:
+    def duration(self) -> pulumi.Input[str]:
         """
         The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
         """
         return pulumi.get(self, "duration")
 
     @duration.setter
-    def duration(self, value: Optional[pulumi.Input[str]]):
+    def duration(self, value: pulumi.Input[str]):
         pulumi.set(self, "duration", value)
 
     @property
     @pulumi.getter
-    def enable(self) -> Optional[pulumi.Input[bool]]:
+    def enable(self) -> pulumi.Input[bool]:
         """
         Whether to open the maintenance window. The following parameters take effect only `enable = true`.
         """
         return pulumi.get(self, "enable")
 
     @enable.setter
-    def enable(self, value: Optional[pulumi.Input[bool]]):
+    def enable(self, value: pulumi.Input[bool]):
         pulumi.set(self, "enable", value)
 
     @property
     @pulumi.getter(name="maintenanceTime")
-    def maintenance_time(self) -> Optional[pulumi.Input[str]]:
+    def maintenance_time(self) -> pulumi.Input[str]:
         """
-        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
+        Initial maintenance time, For example:"03:00:00Z".
         """
         return pulumi.get(self, "maintenance_time")
 
     @maintenance_time.setter
-    def maintenance_time(self, value: Optional[pulumi.Input[str]]):
+    def maintenance_time(self, value: pulumi.Input[str]):
         pulumi.set(self, "maintenance_time", value)
 
     @property
     @pulumi.getter(name="weeklyPeriod")
-    def weekly_period(self) -> Optional[pulumi.Input[str]]:
+    def weekly_period(self) -> pulumi.Input[str]:
         """
         Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
 
@@ -2255,7 +1669,7 @@ class ManagedKubernetesMaintenanceWindowArgs:
         ```
         maintenance_window {
         enable            = true
-        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
+        maintenance_time  = "01:00:00Z"
         duration          = "3h"
         weekly_period     = "Monday,Friday"
         }
@@ -2264,145 +1678,10 @@ class ManagedKubernetesMaintenanceWindowArgs:
         return pulumi.get(self, "weekly_period")
 
     @weekly_period.setter
-    def weekly_period(self, value: Optional[pulumi.Input[str]]):
+    def weekly_period(self, value: pulumi.Input[str]):
         pulumi.set(self, "weekly_period", value)
 
 
-if not MYPY:
-    class ManagedKubernetesOperationPolicyArgsDict(TypedDict):
-        cluster_auto_upgrade: NotRequired[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict']]
-        """
-        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
-        """
-elif False:
-    ManagedKubernetesOperationPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ManagedKubernetesOperationPolicyArgs:
-    def __init__(__self__, *,
-                 cluster_auto_upgrade: Optional[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs']] = None):
-        """
-        :param pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs'] cluster_auto_upgrade: Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
-        """
-        if cluster_auto_upgrade is not None:
-            pulumi.set(__self__, "cluster_auto_upgrade", cluster_auto_upgrade)
-
-    @property
-    @pulumi.getter(name="clusterAutoUpgrade")
-    def cluster_auto_upgrade(self) -> Optional[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs']]:
-        """
-        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
-        """
-        return pulumi.get(self, "cluster_auto_upgrade")
-
-    @cluster_auto_upgrade.setter
-    def cluster_auto_upgrade(self, value: Optional[pulumi.Input['ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs']]):
-        pulumi.set(self, "cluster_auto_upgrade", value)
-
-
-if not MYPY:
-    class ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict(TypedDict):
-        channel: NotRequired[pulumi.Input[str]]
-        """
-        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapic`.
-
-        for example:
-        ```
-        operation_policy {
-        cluster_auto_upgrade {
-        enabled = true
-        channel = "stable"
-        }
-        }
-        ```
-        """
-        enabled: NotRequired[pulumi.Input[bool]]
-        """
-        Whether the RRSA feature has been enabled.
-        """
-elif False:
-    ManagedKubernetesOperationPolicyClusterAutoUpgradeArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ManagedKubernetesOperationPolicyClusterAutoUpgradeArgs:
-    def __init__(__self__, *,
-                 channel: Optional[pulumi.Input[str]] = None,
-                 enabled: Optional[pulumi.Input[bool]] = None):
-        """
-        :param pulumi.Input[str] channel: The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapic`.
-               
-               for example:
-               ```
-               operation_policy {
-               cluster_auto_upgrade {
-               enabled = true
-               channel = "stable"
-               }
-               }
-               ```
-        :param pulumi.Input[bool] enabled: Whether the RRSA feature has been enabled.
-        """
-        if channel is not None:
-            pulumi.set(__self__, "channel", channel)
-        if enabled is not None:
-            pulumi.set(__self__, "enabled", enabled)
-
-    @property
-    @pulumi.getter
-    def channel(self) -> Optional[pulumi.Input[str]]:
-        """
-        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapic`.
-
-        for example:
-        ```
-        operation_policy {
-        cluster_auto_upgrade {
-        enabled = true
-        channel = "stable"
-        }
-        }
-        ```
-        """
-        return pulumi.get(self, "channel")
-
-    @channel.setter
-    def channel(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "channel", value)
-
-    @property
-    @pulumi.getter
-    def enabled(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Whether the RRSA feature has been enabled.
-        """
-        return pulumi.get(self, "enabled")
-
-    @enabled.setter
-    def enabled(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "enabled", value)
-
-
-if not MYPY:
-    class ManagedKubernetesRrsaMetadataArgsDict(TypedDict):
-        enabled: NotRequired[pulumi.Input[bool]]
-        """
-        Whether the RRSA feature has been enabled.
-        """
-        ram_oidc_provider_arn: NotRequired[pulumi.Input[str]]
-        """
-        The arn of OIDC provider that was registered in RAM.
-        """
-        ram_oidc_provider_name: NotRequired[pulumi.Input[str]]
-        """
-        The name of OIDC Provider that was registered in RAM.
-        """
-        rrsa_oidc_issuer_url: NotRequired[pulumi.Input[str]]
-        """
-        The issuer URL of RRSA OIDC Token.
-        """
-elif False:
-    ManagedKubernetesRrsaMetadataArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ManagedKubernetesRrsaMetadataArgs:
     def __init__(__self__, *,
@@ -2474,67 +1753,6 @@ class ManagedKubernetesRrsaMetadataArgs:
         pulumi.set(self, "rrsa_oidc_issuer_url", value)
 
 
-if not MYPY:
-    class NodePoolDataDiskArgsDict(TypedDict):
-        auto_format: NotRequired[pulumi.Input[str]]
-        """
-        Whether to automatically mount the data disk. Valid values: true and false.
-        """
-        auto_snapshot_policy_id: NotRequired[pulumi.Input[str]]
-        """
-        The ID of the automatic snapshot policy that you want to apply to the system disk.
-        """
-        bursting_enabled: NotRequired[pulumi.Input[bool]]
-        """
-        Whether the data disk is enabled with Burst (performance Burst). This is configured when the disk type is cloud_auto.
-        """
-        category: NotRequired[pulumi.Input[str]]
-        """
-        The type of the data disks. Valid values:`cloud`, `cloud_efficiency`, `cloud_ssd`, `cloud_essd`, `cloud_auto`.
-        """
-        device: NotRequired[pulumi.Input[str]]
-        """
-        The mount target of data disk N. Valid values of N: 1 to 16. If you do not specify this parameter, the system automatically assigns a mount target when Auto Scaling creates ECS instances. The name of the mount target ranges from /dev/xvdb to /dev/xvdz.
-        """
-        encrypted: NotRequired[pulumi.Input[str]]
-        """
-        Specifies whether to encrypt data disks. Valid values: true and false. Default to `false`.
-        """
-        file_system: NotRequired[pulumi.Input[str]]
-        """
-        The Mount path. Works when auto_format is true.
-        """
-        kms_key_id: NotRequired[pulumi.Input[str]]
-        """
-        The kms key id used to encrypt the data disk. It takes effect when `encrypted` is true.
-        """
-        mount_target: NotRequired[pulumi.Input[str]]
-        """
-        The type of the mounted file system. Works when auto_format is true. Optional value: `ext4`, `xfs`.
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        The length is 2~128 English or Chinese characters. It must start with an uppercase or lowr letter or a Chinese character and cannot start with http:// or https. Can contain numbers, colons (:), underscores (_), or dashes (-). It will be overwritten if auto_format is set.
-        """
-        performance_level: NotRequired[pulumi.Input[str]]
-        """
-        Worker node data disk performance level, when `category` values `cloud_essd`, the optional values are `PL0`, `PL1`, `PL2` or `PL3`, but the specific performance level is related to the disk capacity. For more information, see [Enhanced SSDs](https://www.alibabacloud.com/help/doc-detail/122389.htm). Default is `PL1`.
-        """
-        provisioned_iops: NotRequired[pulumi.Input[int]]
-        """
-        The read/write IOPS preconfigured for the data disk, which is configured when the disk type is cloud_auto.
-        """
-        size: NotRequired[pulumi.Input[int]]
-        """
-        The size of a data disk, Its valid value range [40~32768] in GB. Default to `40`.
-        """
-        snapshot_id: NotRequired[pulumi.Input[str]]
-        """
-        The ID of the snapshot that you want to use to create data disk N. Valid values of N: 1 to 16. If you specify this parameter, DataDisk.N.Size is ignored. The size of the disk is the same as the size of the specified snapshot. If you specify a snapshot that is created on or before July 15, 2013, the operation fails and InvalidSnapshot.TooOld is returned.
-        """
-elif False:
-    NodePoolDataDiskArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolDataDiskArgs:
     def __init__(__self__, *,
@@ -2766,109 +1984,28 @@ class NodePoolDataDiskArgs:
         pulumi.set(self, "snapshot_id", value)
 
 
-if not MYPY:
-    class NodePoolKubeletConfigurationArgsDict(TypedDict):
-        allowed_unsafe_sysctls: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
-        """
-        Allowed sysctl mode whitelist.
-        """
-        container_log_max_files: NotRequired[pulumi.Input[str]]
-        """
-        The maximum number of log files that can exist in each container.
-        """
-        container_log_max_size: NotRequired[pulumi.Input[str]]
-        """
-        The maximum size that can be reached before a log file is rotated.
-        """
-        cpu_manager_policy: NotRequired[pulumi.Input[str]]
-        """
-        Same as cpuManagerPolicy. The name of the policy to use. Requires the CPUManager feature gate to be enabled. Valid value is `none` or `static`.
-        """
-        event_burst: NotRequired[pulumi.Input[str]]
-        """
-        Same as eventBurst. The maximum size of a burst of event creations, temporarily allows event creations to burst to this number, while still not exceeding `event_record_qps`. It is only used when `event_record_qps` is greater than 0. Valid value is `[0-100]`.
-        """
-        event_record_qps: NotRequired[pulumi.Input[str]]
-        """
-        Same as eventRecordQPS. The maximum event creations per second. If 0, there is no limit enforced. Valid value is `[0-50]`.
-        """
-        eviction_hard: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Same as evictionHard. The map of signal names to quantities that defines hard eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
-        """
-        eviction_soft: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Same as evictionSoft. The map of signal names to quantities that defines soft eviction thresholds. For example: `{"memory.available" = "300Mi"}`.
-        """
-        eviction_soft_grace_period: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Same as evictionSoftGracePeriod. The map of signal names to quantities that defines grace periods for each soft eviction signal. For example: `{"memory.available" = "30s"}`.
-        """
-        feature_gates: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[bool]]]]
-        """
-        Feature switch to enable configuration of experimental features.
-        """
-        kube_api_burst: NotRequired[pulumi.Input[str]]
-        """
-        Same as kubeAPIBurst. The burst to allow while talking with kubernetes api-server. Valid value is `[0-100]`.
-        """
-        kube_api_qps: NotRequired[pulumi.Input[str]]
-        """
-        Same as kubeAPIQPS. The QPS to use while talking with kubernetes api-server. Valid value is `[0-50]`.
-        """
-        kube_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Same as kubeReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for kubernetes system components. Currently, cpu, memory and local storage for root file system are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
-        """
-        max_pods: NotRequired[pulumi.Input[str]]
-        """
-        The maximum number of running pods.
-        """
-        read_only_port: NotRequired[pulumi.Input[str]]
-        """
-        Read-only port number.
-        """
-        registry_burst: NotRequired[pulumi.Input[str]]
-        """
-        Same as registryBurst. The maximum size of burst pulls, temporarily allows pulls to burst to this number, while still not exceeding `registry_pull_qps`. Only used if `registry_pull_qps` is greater than 0. Valid value is `[0-100]`.
-        """
-        registry_pull_qps: NotRequired[pulumi.Input[str]]
-        """
-        Same as registryPullQPS. The limit of registry pulls per second. Setting it to `0` means no limit. Valid value is `[0-50]`.
-        """
-        serialize_image_pulls: NotRequired[pulumi.Input[str]]
-        """
-        Same as serializeImagePulls. When enabled, it tells the Kubelet to pull images one at a time. We recommend not changing the default value on nodes that run docker daemon with version < 1.9 or an Aufs storage backend. Valid value is `true` or `false`.
-        """
-        system_reserved: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Same as systemReserved. The set of ResourceName=ResourceQuantity (e.g. cpu=200m,memory=150G) pairs that describe resources reserved for non-kubernetes components. Currently, only cpu and memory are supported. See [compute resources](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) for more details.
-        """
-elif False:
-    NodePoolKubeletConfigurationArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class NodePoolKubeletConfigurationArgs:
-    def __init__(__self__, *,
-                 allowed_unsafe_sysctls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 container_log_max_files: Optional[pulumi.Input[str]] = None,
-                 container_log_max_size: Optional[pulumi.Input[str]] = None,
-                 cpu_manager_policy: Optional[pulumi.Input[str]] = None,
-                 event_burst: Optional[pulumi.Input[str]] = None,
-                 event_record_qps: Optional[pulumi.Input[str]] = None,
-                 eviction_hard: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 eviction_soft: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 eviction_soft_grace_period: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 feature_gates: Optional[pulumi.Input[Mapping[str, pulumi.Input[bool]]]] = None,
-                 kube_api_burst: Optional[pulumi.Input[str]] = None,
-                 kube_api_qps: Optional[pulumi.Input[str]] = None,
-                 kube_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-                 max_pods: Optional[pulumi.Input[str]] = None,
-                 read_only_port: Optional[pulumi.Input[str]] = None,
-                 registry_burst: Optional[pulumi.Input[str]] = None,
-                 registry_pull_qps: Optional[pulumi.Input[str]] = None,
-                 serialize_image_pulls: Optional[pulumi.Input[str]] = None,
-                 system_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
+@pulumi.input_type
+class NodePoolKubeletConfigurationArgs:
+    def __init__(__self__, *,
+                 allowed_unsafe_sysctls: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 container_log_max_files: Optional[pulumi.Input[str]] = None,
+                 container_log_max_size: Optional[pulumi.Input[str]] = None,
+                 cpu_manager_policy: Optional[pulumi.Input[str]] = None,
+                 event_burst: Optional[pulumi.Input[str]] = None,
+                 event_record_qps: Optional[pulumi.Input[str]] = None,
+                 eviction_hard: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 eviction_soft: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 eviction_soft_grace_period: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 feature_gates: Optional[pulumi.Input[Mapping[str, pulumi.Input[bool]]]] = None,
+                 kube_api_burst: Optional[pulumi.Input[str]] = None,
+                 kube_api_qps: Optional[pulumi.Input[str]] = None,
+                 kube_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 max_pods: Optional[pulumi.Input[str]] = None,
+                 read_only_port: Optional[pulumi.Input[str]] = None,
+                 registry_burst: Optional[pulumi.Input[str]] = None,
+                 registry_pull_qps: Optional[pulumi.Input[str]] = None,
+                 serialize_image_pulls: Optional[pulumi.Input[str]] = None,
+                 system_reserved: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_unsafe_sysctls: Allowed sysctl mode whitelist.
         :param pulumi.Input[str] container_log_max_files: The maximum number of log files that can exist in each container.
@@ -3158,19 +2295,6 @@ class NodePoolKubeletConfigurationArgs:
         pulumi.set(self, "system_reserved", value)
 
 
-if not MYPY:
-    class NodePoolLabelArgsDict(TypedDict):
-        key: pulumi.Input[str]
-        """
-        The label key.
-        """
-        value: NotRequired[pulumi.Input[str]]
-        """
-        The label value.
-        """
-elif False:
-    NodePoolLabelArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolLabelArgs:
     def __init__(__self__, *,
@@ -3209,51 +2333,6 @@ class NodePoolLabelArgs:
         pulumi.set(self, "value", value)
 
 
-if not MYPY:
-    class NodePoolManagementArgsDict(TypedDict):
-        auto_repair: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to enable automatic repair. Valid values: `true`: Automatic repair. `false`: not automatically repaired.
-        """
-        auto_repair_policy: NotRequired[pulumi.Input['NodePoolManagementAutoRepairPolicyArgsDict']]
-        """
-        Automatic repair node policy. See `auto_repair_policy` below.
-        """
-        auto_upgrade: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to enable auto update. Valid values: `true`: enables auto update. `false`: disables auto update.
-        """
-        auto_upgrade_policy: NotRequired[pulumi.Input['NodePoolManagementAutoUpgradePolicyArgsDict']]
-        """
-        The auto update policy. See `auto_upgrade_policy` below.
-        """
-        auto_vul_fix: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to automatically patch CVE vulnerabilities. Valid values: `true`, `false`.
-        """
-        auto_vul_fix_policy: NotRequired[pulumi.Input['NodePoolManagementAutoVulFixPolicyArgsDict']]
-        """
-        The auto CVE patching policy. See `auto_vul_fix_policy` below.
-        """
-        enable: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to enable the managed node pool feature. Valid values: `true`: enables the managed node pool feature. `false`: disables the managed node pool feature. Other parameters in this section take effect only when you specify enable=true.
-        """
-        max_unavailable: NotRequired[pulumi.Input[int]]
-        """
-        Maximum number of unavailable nodes. Default value: 1. Value range:\\[1,1000\\].
-        """
-        surge: NotRequired[pulumi.Input[int]]
-        """
-        Number of additional nodes. You have to specify one of surge, surge_percentage.
-        """
-        surge_percentage: NotRequired[pulumi.Input[int]]
-        """
-        Proportion of additional nodes. You have to specify one of surge, surge_percentage.
-        """
-elif False:
-    NodePoolManagementArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolManagementArgs:
     def __init__(__self__, *,
@@ -3429,15 +2508,6 @@ class NodePoolManagementArgs:
         pulumi.set(self, "surge_percentage", value)
 
 
-if not MYPY:
-    class NodePoolManagementAutoRepairPolicyArgsDict(TypedDict):
-        restart_node: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
-        """
-elif False:
-    NodePoolManagementAutoRepairPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolManagementAutoRepairPolicyArgs:
     def __init__(__self__, *,
@@ -3461,15 +2531,6 @@ class NodePoolManagementAutoRepairPolicyArgs:
         pulumi.set(self, "restart_node", value)
 
 
-if not MYPY:
-    class NodePoolManagementAutoUpgradePolicyArgsDict(TypedDict):
-        auto_upgrade_kubelet: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether  to automatically update the kubelet. Valid values: `true`: yes; `false`: no.
-        """
-elif False:
-    NodePoolManagementAutoUpgradePolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolManagementAutoUpgradePolicyArgs:
     def __init__(__self__, *,
@@ -3493,19 +2554,6 @@ class NodePoolManagementAutoUpgradePolicyArgs:
         pulumi.set(self, "auto_upgrade_kubelet", value)
 
 
-if not MYPY:
-    class NodePoolManagementAutoVulFixPolicyArgsDict(TypedDict):
-        restart_node: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to automatically restart nodes after patching CVE vulnerabilities. Valid values: `true`, `false`.
-        """
-        vul_level: NotRequired[pulumi.Input[str]]
-        """
-        The severity levels of vulnerabilities that is allowed to automatically patch. Multiple severity levels are separated by commas (,).
-        """
-elif False:
-    NodePoolManagementAutoVulFixPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolManagementAutoVulFixPolicyArgs:
     def __init__(__self__, *,
@@ -3545,19 +2593,6 @@ class NodePoolManagementAutoVulFixPolicyArgs:
         pulumi.set(self, "vul_level", value)
 
 
-if not MYPY:
-    class NodePoolPrivatePoolOptionsArgsDict(TypedDict):
-        private_pool_options_id: NotRequired[pulumi.Input[str]]
-        """
-        The ID of the private node pool.
-        """
-        private_pool_options_match_criteria: NotRequired[pulumi.Input[str]]
-        """
-        The type of private node pool. This parameter specifies the type of the private pool that you want to use to create instances. A private node pool is generated when an elasticity assurance or a capacity reservation service takes effect. The system selects a private node pool to launch instances. Valid values: `Open`: specifies an open private node pool. The system selects an open private node pool to launch instances. If no matching open private node pool is available, the resources in the public node pool are used. `Target`: specifies a private node pool. The system uses the resources of the specified private node pool to launch instances. If the specified private node pool is unavailable, instances cannot be started. `None`: no private node pool is used. The resources of private node pools are not used to launch the instances.
-        """
-elif False:
-    NodePoolPrivatePoolOptionsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolPrivatePoolOptionsArgs:
     def __init__(__self__, *,
@@ -3597,15 +2632,6 @@ class NodePoolPrivatePoolOptionsArgs:
         pulumi.set(self, "private_pool_options_match_criteria", value)
 
 
-if not MYPY:
-    class NodePoolRollingPolicyArgsDict(TypedDict):
-        max_parallelism: NotRequired[pulumi.Input[int]]
-        """
-        The maximum number of unusable nodes.
-        """
-elif False:
-    NodePoolRollingPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolRollingPolicyArgs:
     def __init__(__self__, *,
@@ -3629,39 +2655,6 @@ class NodePoolRollingPolicyArgs:
         pulumi.set(self, "max_parallelism", value)
 
 
-if not MYPY:
-    class NodePoolScalingConfigArgsDict(TypedDict):
-        eip_bandwidth: NotRequired[pulumi.Input[int]]
-        """
-        Peak EIP bandwidth. Its valid value range [1~500] in Mbps. It works if `is_bond_eip=true`. Default to `5`.
-        """
-        eip_internet_charge_type: NotRequired[pulumi.Input[str]]
-        """
-        EIP billing type. `PayByBandwidth`: Charged at fixed bandwidth. `PayByTraffic`: Billed as used traffic. Default: `PayByBandwidth`. It works if `is_bond_eip=true`, conflict with `internet_charge_type`. EIP and public network IP can only choose one.
-        """
-        enable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to enable automatic scaling. Value:
-        """
-        is_bond_eip: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to bind EIP for an instance. Default: `false`.
-        """
-        max_size: NotRequired[pulumi.Input[int]]
-        """
-        Max number of instances in a auto scaling group, its valid value range [0~1000]. `max_size` has to be greater than `min_size`.
-        """
-        min_size: NotRequired[pulumi.Input[int]]
-        """
-        Min number of instances in a auto scaling group, its valid value range [0~1000].
-        """
-        type: NotRequired[pulumi.Input[str]]
-        """
-        Instance classification, not required. Vaild value: `cpu`, `gpu`, `gpushare` and `spot`. Default: `cpu`. The actual instance type is determined by `instance_types`.
-        """
-elif False:
-    NodePoolScalingConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolScalingConfigArgs:
     def __init__(__self__, *,
@@ -3781,19 +2774,6 @@ class NodePoolScalingConfigArgs:
         pulumi.set(self, "type", value)
 
 
-if not MYPY:
-    class NodePoolSpotPriceLimitArgsDict(TypedDict):
-        instance_type: NotRequired[pulumi.Input[str]]
-        """
-        The type of the preemptible instance.
-        """
-        price_limit: NotRequired[pulumi.Input[str]]
-        """
-        The maximum price of a single instance.
-        """
-elif False:
-    NodePoolSpotPriceLimitArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolSpotPriceLimitArgs:
     def __init__(__self__, *,
@@ -3833,23 +2813,6 @@ class NodePoolSpotPriceLimitArgs:
         pulumi.set(self, "price_limit", value)
 
 
-if not MYPY:
-    class NodePoolTaintArgsDict(TypedDict):
-        key: pulumi.Input[str]
-        """
-        The key of a taint.
-        """
-        effect: NotRequired[pulumi.Input[str]]
-        """
-        The scheduling policy.
-        """
-        value: NotRequired[pulumi.Input[str]]
-        """
-        The value of a taint.
-        """
-elif False:
-    NodePoolTaintArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolTaintArgs:
     def __init__(__self__, *,
@@ -3904,15 +2867,6 @@ class NodePoolTaintArgs:
         pulumi.set(self, "value", value)
 
 
-if not MYPY:
-    class NodePoolTeeConfigArgsDict(TypedDict):
-        tee_enable: NotRequired[pulumi.Input[bool]]
-        """
-        Specifies whether to enable confidential computing for the cluster.
-        """
-elif False:
-    NodePoolTeeConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class NodePoolTeeConfigArgs:
     def __init__(__self__, *,
@@ -3936,56 +2890,6 @@ class NodePoolTeeConfigArgs:
         pulumi.set(self, "tee_enable", value)
 
 
-if not MYPY:
-    class ServerlessKubernetesAddonArgsDict(TypedDict):
-        config: NotRequired[pulumi.Input[str]]
-        """
-        The ACK add-on configurations. For more config information, see cs_kubernetes_addon_metadata.
-        """
-        disabled: NotRequired[pulumi.Input[bool]]
-        """
-        Disables the automatic installation of a component. Default is `false`.
-
-        The following example is the definition of addons block, The type of this field is list:
-
-        ```
-        # install nginx ingress, conflict with ALB ingress
-        addons {
-        name = "nginx-ingress-controller"
-        # use internet
-        config = "{\\"IngressSlbNetworkType\\":\\"internet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
-        # if use intranet, detail below.
-        # config = "{\\"IngressSlbNetworkType\\":\\"intranet",\\"IngressSlbSpec\\":\\"slb.s2.small\\"}"
-        }
-        # install ALB ingress, conflict with nginx ingress
-        addons {
-        name = "alb-ingress-controller"
-        }
-        # install metric server
-        addons {
-        name = "metrics-server"
-        }
-        # install knative
-        addons {
-        name = "knative"
-        }
-        # install prometheus
-        addons {
-        name = "arms-prometheus"
-        }
-        ```
-        """
-        name: NotRequired[pulumi.Input[str]]
-        """
-        Name of the ACK add-on. The name must match one of the names returned by [DescribeAddons](https://help.aliyun.com/document_detail/171524.html).
-        """
-        version: NotRequired[pulumi.Input[str]]
-        """
-        It specifies the version of the component.
-        """
-elif False:
-    ServerlessKubernetesAddonArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ServerlessKubernetesAddonArgs:
     def __init__(__self__, *,
@@ -4115,53 +3019,6 @@ class ServerlessKubernetesAddonArgs:
         pulumi.set(self, "version", value)
 
 
-if not MYPY:
-    class ServerlessKubernetesDeleteOptionArgsDict(TypedDict):
-        delete_mode: NotRequired[pulumi.Input[str]]
-        """
-        The deletion mode of the cluster. Different resources may have different default behavior, see `resource_type` for details. Valid values:
-        """
-        resource_type: NotRequired[pulumi.Input[str]]
-        """
-        The type of resources that are created by cluster. Valid values:
-        - `SLB`: SLB resources created by the Nginx Ingress Service, default behavior is to delete, option to retain is available.
-        - `ALB`: ALB resources created by the ALB Ingress Controller, default behavior is to retain, option to delete is available.
-        - `SLS_Data`: SLS Project used by the cluster logging feature, default behavior is to retain, option to delete is available.
-        - `SLS_ControlPlane`: SLS Project used for the managed cluster control plane logs, default behavior is to retain, option to delete is available.
-        - `PrivateZone`: PrivateZone resources created by the cluster, default behavior is to retain, option to delete is available.
-        ```
-        ...
-        // Specify delete_options as below when deleting cluster
-        // delete SLB resources created by the Nginx Ingress Service
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLB"
-        }
-        // delete ALB resources created by the ALB Ingress Controller
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "ALB"
-        }
-        // delete SLS Project used by the cluster logging feature
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLS_Data"
-        }
-        // delete SLS Project used for the managed cluster control plane logs
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "SLS_ControlPlane"
-        }
-        // delete PrivateZone resources created by the cluster
-        delete_options {
-        delete_mode = "delete"
-        resource_type = "PrivateZone"
-        }
-        ```
-        """
-elif False:
-    ServerlessKubernetesDeleteOptionArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ServerlessKubernetesDeleteOptionArgs:
     def __init__(__self__, *,
@@ -4269,263 +3126,6 @@ class ServerlessKubernetesDeleteOptionArgs:
         pulumi.set(self, "resource_type", value)
 
 
-if not MYPY:
-    class ServerlessKubernetesMaintenanceWindowArgsDict(TypedDict):
-        duration: NotRequired[pulumi.Input[str]]
-        """
-        The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
-        """
-        enable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether to open the maintenance window. The following parameters take effect only `enable = true`.
-        """
-        maintenance_time: NotRequired[pulumi.Input[str]]
-        """
-        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
-        """
-        weekly_period: NotRequired[pulumi.Input[str]]
-        """
-        Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
-
-        for example:
-        ```
-        maintenance_window {
-        enable            = true
-        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
-        duration          = "3h"
-        weekly_period     = "Monday,Friday"
-        }
-        ```
-        """
-elif False:
-    ServerlessKubernetesMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ServerlessKubernetesMaintenanceWindowArgs:
-    def __init__(__self__, *,
-                 duration: Optional[pulumi.Input[str]] = None,
-                 enable: Optional[pulumi.Input[bool]] = None,
-                 maintenance_time: Optional[pulumi.Input[str]] = None,
-                 weekly_period: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] duration: The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
-        :param pulumi.Input[bool] enable: Whether to open the maintenance window. The following parameters take effect only `enable = true`.
-        :param pulumi.Input[str] maintenance_time: Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
-        :param pulumi.Input[str] weekly_period: Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
-               
-               for example:
-               ```
-               maintenance_window {
-               enable            = true
-               maintenance_time  = "2024-10-15T12:31:00.000+08:00"
-               duration          = "3h"
-               weekly_period     = "Monday,Friday"
-               }
-               ```
-        """
-        if duration is not None:
-            pulumi.set(__self__, "duration", duration)
-        if enable is not None:
-            pulumi.set(__self__, "enable", enable)
-        if maintenance_time is not None:
-            pulumi.set(__self__, "maintenance_time", maintenance_time)
-        if weekly_period is not None:
-            pulumi.set(__self__, "weekly_period", weekly_period)
-
-    @property
-    @pulumi.getter
-    def duration(self) -> Optional[pulumi.Input[str]]:
-        """
-        The maintenance time, values range from 1 to 24,unit is hour. For example: "3h".
-        """
-        return pulumi.get(self, "duration")
-
-    @duration.setter
-    def duration(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "duration", value)
-
-    @property
-    @pulumi.getter
-    def enable(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Whether to open the maintenance window. The following parameters take effect only `enable = true`.
-        """
-        return pulumi.get(self, "enable")
-
-    @enable.setter
-    def enable(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "enable", value)
-
-    @property
-    @pulumi.getter(name="maintenanceTime")
-    def maintenance_time(self) -> Optional[pulumi.Input[str]]:
-        """
-        Initial maintenance time, RFC3339 format. For example: "2024-10-15T12:31:00.000+08:00".
-        """
-        return pulumi.get(self, "maintenance_time")
-
-    @maintenance_time.setter
-    def maintenance_time(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "maintenance_time", value)
-
-    @property
-    @pulumi.getter(name="weeklyPeriod")
-    def weekly_period(self) -> Optional[pulumi.Input[str]]:
-        """
-        Maintenance cycle, you can set the values from Monday to Sunday, separated by commas when the values are multiple. The default is Thursday.
-
-        for example:
-        ```
-        maintenance_window {
-        enable            = true
-        maintenance_time  = "2024-10-15T12:31:00.000+08:00"
-        duration          = "3h"
-        weekly_period     = "Monday,Friday"
-        }
-        ```
-        """
-        return pulumi.get(self, "weekly_period")
-
-    @weekly_period.setter
-    def weekly_period(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "weekly_period", value)
-
-
-if not MYPY:
-    class ServerlessKubernetesOperationPolicyArgsDict(TypedDict):
-        cluster_auto_upgrade: NotRequired[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict']]
-        """
-        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
-        """
-elif False:
-    ServerlessKubernetesOperationPolicyArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ServerlessKubernetesOperationPolicyArgs:
-    def __init__(__self__, *,
-                 cluster_auto_upgrade: Optional[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs']] = None):
-        """
-        :param pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs'] cluster_auto_upgrade: Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
-        """
-        if cluster_auto_upgrade is not None:
-            pulumi.set(__self__, "cluster_auto_upgrade", cluster_auto_upgrade)
-
-    @property
-    @pulumi.getter(name="clusterAutoUpgrade")
-    def cluster_auto_upgrade(self) -> Optional[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs']]:
-        """
-        Automatic cluster upgrade policy. See `cluster_auto_upgrade` below.
-        """
-        return pulumi.get(self, "cluster_auto_upgrade")
-
-    @cluster_auto_upgrade.setter
-    def cluster_auto_upgrade(self, value: Optional[pulumi.Input['ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs']]):
-        pulumi.set(self, "cluster_auto_upgrade", value)
-
-
-if not MYPY:
-    class ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict(TypedDict):
-        channel: NotRequired[pulumi.Input[str]]
-        """
-        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapic`.
-
-        for example:
-        ```
-        operation_policy {
-        cluster_auto_upgrade {
-        enabled = true
-        channel = "stable"
-        }
-        }
-        ```
-        """
-        enabled: NotRequired[pulumi.Input[bool]]
-        """
-        Whether the RRSA feature has been enabled.
-        """
-elif False:
-    ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ServerlessKubernetesOperationPolicyClusterAutoUpgradeArgs:
-    def __init__(__self__, *,
-                 channel: Optional[pulumi.Input[str]] = None,
-                 enabled: Optional[pulumi.Input[bool]] = None):
-        """
-        :param pulumi.Input[str] channel: The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapic`.
-               
-               for example:
-               ```
-               operation_policy {
-               cluster_auto_upgrade {
-               enabled = true
-               channel = "stable"
-               }
-               }
-               ```
-        :param pulumi.Input[bool] enabled: Whether the RRSA feature has been enabled.
-        """
-        if channel is not None:
-            pulumi.set(__self__, "channel", channel)
-        if enabled is not None:
-            pulumi.set(__self__, "enabled", enabled)
-
-    @property
-    @pulumi.getter
-    def channel(self) -> Optional[pulumi.Input[str]]:
-        """
-        The automatic cluster upgrade channel. Valid values: `patch`, `stable`, `rapic`.
-
-        for example:
-        ```
-        operation_policy {
-        cluster_auto_upgrade {
-        enabled = true
-        channel = "stable"
-        }
-        }
-        ```
-        """
-        return pulumi.get(self, "channel")
-
-    @channel.setter
-    def channel(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "channel", value)
-
-    @property
-    @pulumi.getter
-    def enabled(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Whether the RRSA feature has been enabled.
-        """
-        return pulumi.get(self, "enabled")
-
-    @enabled.setter
-    def enabled(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "enabled", value)
-
-
-if not MYPY:
-    class ServerlessKubernetesRrsaMetadataArgsDict(TypedDict):
-        enabled: NotRequired[pulumi.Input[bool]]
-        """
-        Whether the RRSA feature has been enabled.
-        """
-        ram_oidc_provider_arn: NotRequired[pulumi.Input[str]]
-        """
-        The arn of OIDC provider that was registered in RAM.
-        """
-        ram_oidc_provider_name: NotRequired[pulumi.Input[str]]
-        """
-        The name of OIDC Provider that was registered in RAM.
-        """
-        rrsa_oidc_issuer_url: NotRequired[pulumi.Input[str]]
-        """
-        The issuer URL of RRSA OIDC Token.
-        """
-elif False:
-    ServerlessKubernetesRrsaMetadataArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ServerlessKubernetesRrsaMetadataArgs:
     def __init__(__self__, *,
@@ -4597,16 +3197,6 @@ class ServerlessKubernetesRrsaMetadataArgs:
         pulumi.set(self, "rrsa_oidc_issuer_url", value)
 
 
-if not MYPY:
-    class SwarmNodeArgsDict(TypedDict):
-        eip: NotRequired[pulumi.Input[str]]
-        id: NotRequired[pulumi.Input[str]]
-        name: NotRequired[pulumi.Input[str]]
-        private_ip: NotRequired[pulumi.Input[str]]
-        status: NotRequired[pulumi.Input[str]]
-elif False:
-    SwarmNodeArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class SwarmNodeArgs:
     def __init__(__self__, *,