# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
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__ = [
    'AddonStatusArgs',
    'AddonStatusArgsDict',
    'AddonStatusConditionArgs',
    'AddonStatusConditionArgsDict',
    'ClusterClusterConfigArgs',
    'ClusterClusterConfigArgsDict',
    'ClusterClusterConfigApiServerEndpointsArgs',
    'ClusterClusterConfigApiServerEndpointsArgsDict',
    'ClusterClusterConfigApiServerEndpointsPrivateIpArgs',
    'ClusterClusterConfigApiServerEndpointsPrivateIpArgsDict',
    'ClusterClusterConfigApiServerEndpointsPublicIpArgs',
    'ClusterClusterConfigApiServerEndpointsPublicIpArgsDict',
    'ClusterClusterConfigApiServerPublicAccessConfigArgs',
    'ClusterClusterConfigApiServerPublicAccessConfigArgsDict',
    'ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs',
    'ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgsDict',
    'ClusterLoggingConfigArgs',
    'ClusterLoggingConfigArgsDict',
    'ClusterLoggingConfigLogSetupArgs',
    'ClusterLoggingConfigLogSetupArgsDict',
    'ClusterMonitoringConfigArgs',
    'ClusterMonitoringConfigArgsDict',
    'ClusterMonitoringConfigComponentConfigArgs',
    'ClusterMonitoringConfigComponentConfigArgsDict',
    'ClusterNodeStatisticsArgs',
    'ClusterNodeStatisticsArgsDict',
    'ClusterPodsConfigArgs',
    'ClusterPodsConfigArgsDict',
    'ClusterPodsConfigFlannelConfigArgs',
    'ClusterPodsConfigFlannelConfigArgsDict',
    'ClusterPodsConfigVpcCniConfigArgs',
    'ClusterPodsConfigVpcCniConfigArgsDict',
    'ClusterServicesConfigArgs',
    'ClusterServicesConfigArgsDict',
    'ClusterStatusArgs',
    'ClusterStatusArgsDict',
    'ClusterStatusConditionArgs',
    'ClusterStatusConditionArgsDict',
    'ClusterTagArgs',
    'ClusterTagArgsDict',
    'NodePoolAutoScalingArgs',
    'NodePoolAutoScalingArgsDict',
    'NodePoolKubernetesConfigArgs',
    'NodePoolKubernetesConfigArgsDict',
    'NodePoolKubernetesConfigKubeletConfigArgs',
    'NodePoolKubernetesConfigKubeletConfigArgsDict',
    'NodePoolKubernetesConfigKubeletConfigFeatureGatesArgs',
    'NodePoolKubernetesConfigKubeletConfigFeatureGatesArgsDict',
    'NodePoolKubernetesConfigKubeletConfigKubeReservedArgs',
    'NodePoolKubernetesConfigKubeletConfigKubeReservedArgsDict',
    'NodePoolKubernetesConfigKubeletConfigSystemReservedArgs',
    'NodePoolKubernetesConfigKubeletConfigSystemReservedArgsDict',
    'NodePoolKubernetesConfigLabelArgs',
    'NodePoolKubernetesConfigLabelArgsDict',
    'NodePoolKubernetesConfigTaintArgs',
    'NodePoolKubernetesConfigTaintArgsDict',
    'NodePoolManagementArgs',
    'NodePoolManagementArgsDict',
    'NodePoolManagementRemedyConfigArgs',
    'NodePoolManagementRemedyConfigArgsDict',
    'NodePoolNodeConfigArgs',
    'NodePoolNodeConfigArgsDict',
    'NodePoolNodeConfigDataVolumeArgs',
    'NodePoolNodeConfigDataVolumeArgsDict',
    'NodePoolNodeConfigInstancesDistributionArgs',
    'NodePoolNodeConfigInstancesDistributionArgsDict',
    'NodePoolNodeConfigPublicAccessConfigArgs',
    'NodePoolNodeConfigPublicAccessConfigArgsDict',
    'NodePoolNodeConfigSecurityArgs',
    'NodePoolNodeConfigSecurityArgsDict',
    'NodePoolNodeConfigSecurityLoginArgs',
    'NodePoolNodeConfigSecurityLoginArgsDict',
    'NodePoolNodeConfigSystemVolumeArgs',
    'NodePoolNodeConfigSystemVolumeArgsDict',
    'NodePoolNodeConfigTagArgs',
    'NodePoolNodeConfigTagArgsDict',
    'NodePoolNodeStatisticsArgs',
    'NodePoolNodeStatisticsArgsDict',
    'NodePoolStatusArgs',
    'NodePoolStatusArgsDict',
    'NodePoolStatusConditionArgs',
    'NodePoolStatusConditionArgsDict',
    'NodePoolTagArgs',
    'NodePoolTagArgsDict',
]

MYPY = False

if not MYPY:
    class AddonStatusArgsDict(TypedDict):
        conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['AddonStatusConditionArgsDict']]]]
        phase: NotRequired[pulumi.Input[builtins.str]]
        """
        组件的状态，参数值有：Running, Failed, Creating, Deleting, Updating
        """
elif False:
    AddonStatusArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AddonStatusArgs:
    def __init__(__self__, *,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['AddonStatusConditionArgs']]]] = None,
                 phase: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] phase: 组件的状态，参数值有：Running, Failed, Creating, Deleting, Updating
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if phase is not None:
            pulumi.set(__self__, "phase", phase)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AddonStatusConditionArgs']]]]:
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AddonStatusConditionArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def phase(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        组件的状态，参数值有：Running, Failed, Creating, Deleting, Updating
        """
        return pulumi.get(self, "phase")

    @phase.setter
    def phase(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "phase", value)


if not MYPY:
    class AddonStatusConditionArgsDict(TypedDict):
        pass
elif False:
    AddonStatusConditionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AddonStatusConditionArgs:
    def __init__(__self__):
        pass


if not MYPY:
    class ClusterClusterConfigArgsDict(TypedDict):
        api_server_endpoints: NotRequired[pulumi.Input['ClusterClusterConfigApiServerEndpointsArgsDict']]
        """
        集群 API Server 访问的 IPv4 地址信息。
        """
        api_server_public_access_config: NotRequired[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigArgsDict']]
        """
        集群 API Server 公网访问配置信息。ApiServerPublicAccessEnable=true时才返回的参数。
        """
        api_server_public_access_enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        节点公网访问配置，参数值说明：false：未开启。true：已开启。
        """
        resource_public_access_default_enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        节点公网访问配置，参数值说明：false：未开启。true：已开启。
        """
        security_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        集群控制面及节点使用的的安全组。
        """
        subnet_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        集群控制面在私有网络内通信的子网 ID。
        """
        vpc_id: NotRequired[pulumi.Input[builtins.str]]
        """
        集群控制面及部分节点的网络所在的私有网络（VPC）ID。
        """
elif False:
    ClusterClusterConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterClusterConfigArgs:
    def __init__(__self__, *,
                 api_server_endpoints: Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsArgs']] = None,
                 api_server_public_access_config: Optional[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigArgs']] = None,
                 api_server_public_access_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 resource_public_access_default_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 vpc_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['ClusterClusterConfigApiServerEndpointsArgs'] api_server_endpoints: 集群 API Server 访问的 IPv4 地址信息。
        :param pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigArgs'] api_server_public_access_config: 集群 API Server 公网访问配置信息。ApiServerPublicAccessEnable=true时才返回的参数。
        :param pulumi.Input[builtins.bool] api_server_public_access_enabled: 节点公网访问配置，参数值说明：false：未开启。true：已开启。
        :param pulumi.Input[builtins.bool] resource_public_access_default_enabled: 节点公网访问配置，参数值说明：false：未开启。true：已开启。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: 集群控制面及节点使用的的安全组。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] subnet_ids: 集群控制面在私有网络内通信的子网 ID。
        :param pulumi.Input[builtins.str] vpc_id: 集群控制面及部分节点的网络所在的私有网络（VPC）ID。
        """
        if api_server_endpoints is not None:
            pulumi.set(__self__, "api_server_endpoints", api_server_endpoints)
        if api_server_public_access_config is not None:
            pulumi.set(__self__, "api_server_public_access_config", api_server_public_access_config)
        if api_server_public_access_enabled is not None:
            pulumi.set(__self__, "api_server_public_access_enabled", api_server_public_access_enabled)
        if resource_public_access_default_enabled is not None:
            pulumi.set(__self__, "resource_public_access_default_enabled", resource_public_access_default_enabled)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if subnet_ids is not None:
            pulumi.set(__self__, "subnet_ids", subnet_ids)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="apiServerEndpoints")
    def api_server_endpoints(self) -> Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsArgs']]:
        """
        集群 API Server 访问的 IPv4 地址信息。
        """
        return pulumi.get(self, "api_server_endpoints")

    @api_server_endpoints.setter
    def api_server_endpoints(self, value: Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsArgs']]):
        pulumi.set(self, "api_server_endpoints", value)

    @property
    @pulumi.getter(name="apiServerPublicAccessConfig")
    def api_server_public_access_config(self) -> Optional[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigArgs']]:
        """
        集群 API Server 公网访问配置信息。ApiServerPublicAccessEnable=true时才返回的参数。
        """
        return pulumi.get(self, "api_server_public_access_config")

    @api_server_public_access_config.setter
    def api_server_public_access_config(self, value: Optional[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigArgs']]):
        pulumi.set(self, "api_server_public_access_config", value)

    @property
    @pulumi.getter(name="apiServerPublicAccessEnabled")
    def api_server_public_access_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        节点公网访问配置，参数值说明：false：未开启。true：已开启。
        """
        return pulumi.get(self, "api_server_public_access_enabled")

    @api_server_public_access_enabled.setter
    def api_server_public_access_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "api_server_public_access_enabled", value)

    @property
    @pulumi.getter(name="resourcePublicAccessDefaultEnabled")
    def resource_public_access_default_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        节点公网访问配置，参数值说明：false：未开启。true：已开启。
        """
        return pulumi.get(self, "resource_public_access_default_enabled")

    @resource_public_access_default_enabled.setter
    def resource_public_access_default_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "resource_public_access_default_enabled", value)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        集群控制面及节点使用的的安全组。
        """
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        集群控制面在私有网络内通信的子网 ID。
        """
        return pulumi.get(self, "subnet_ids")

    @subnet_ids.setter
    def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "subnet_ids", value)

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        集群控制面及部分节点的网络所在的私有网络（VPC）ID。
        """
        return pulumi.get(self, "vpc_id")

    @vpc_id.setter
    def vpc_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "vpc_id", value)


if not MYPY:
    class ClusterClusterConfigApiServerEndpointsArgsDict(TypedDict):
        private_ip: NotRequired[pulumi.Input['ClusterClusterConfigApiServerEndpointsPrivateIpArgsDict']]
        """
        集群 API Server 私网的 IPv4 地址。
        """
        public_ip: NotRequired[pulumi.Input['ClusterClusterConfigApiServerEndpointsPublicIpArgsDict']]
        """
        集群 API Server 公网的 IPv4 地址。
        """
elif False:
    ClusterClusterConfigApiServerEndpointsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterClusterConfigApiServerEndpointsArgs:
    def __init__(__self__, *,
                 private_ip: Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsPrivateIpArgs']] = None,
                 public_ip: Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsPublicIpArgs']] = None):
        """
        :param pulumi.Input['ClusterClusterConfigApiServerEndpointsPrivateIpArgs'] private_ip: 集群 API Server 私网的 IPv4 地址。
        :param pulumi.Input['ClusterClusterConfigApiServerEndpointsPublicIpArgs'] public_ip: 集群 API Server 公网的 IPv4 地址。
        """
        if private_ip is not None:
            pulumi.set(__self__, "private_ip", private_ip)
        if public_ip is not None:
            pulumi.set(__self__, "public_ip", public_ip)

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsPrivateIpArgs']]:
        """
        集群 API Server 私网的 IPv4 地址。
        """
        return pulumi.get(self, "private_ip")

    @private_ip.setter
    def private_ip(self, value: Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsPrivateIpArgs']]):
        pulumi.set(self, "private_ip", value)

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsPublicIpArgs']]:
        """
        集群 API Server 公网的 IPv4 地址。
        """
        return pulumi.get(self, "public_ip")

    @public_ip.setter
    def public_ip(self, value: Optional[pulumi.Input['ClusterClusterConfigApiServerEndpointsPublicIpArgs']]):
        pulumi.set(self, "public_ip", value)


if not MYPY:
    class ClusterClusterConfigApiServerEndpointsPrivateIpArgsDict(TypedDict):
        ipv4: NotRequired[pulumi.Input[builtins.str]]
        """
        私网 IP 的 IPv4 地址。
        """
elif False:
    ClusterClusterConfigApiServerEndpointsPrivateIpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterClusterConfigApiServerEndpointsPrivateIpArgs:
    def __init__(__self__, *,
                 ipv4: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] ipv4: 私网 IP 的 IPv4 地址。
        """
        if ipv4 is not None:
            pulumi.set(__self__, "ipv4", ipv4)

    @property
    @pulumi.getter
    def ipv4(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        私网 IP 的 IPv4 地址。
        """
        return pulumi.get(self, "ipv4")

    @ipv4.setter
    def ipv4(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ipv4", value)


if not MYPY:
    class ClusterClusterConfigApiServerEndpointsPublicIpArgsDict(TypedDict):
        ipv4: NotRequired[pulumi.Input[builtins.str]]
        """
        公网 IP 的 IPv4 地址。
        """
elif False:
    ClusterClusterConfigApiServerEndpointsPublicIpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterClusterConfigApiServerEndpointsPublicIpArgs:
    def __init__(__self__, *,
                 ipv4: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] ipv4: 公网 IP 的 IPv4 地址。
        """
        if ipv4 is not None:
            pulumi.set(__self__, "ipv4", ipv4)

    @property
    @pulumi.getter
    def ipv4(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        公网 IP 的 IPv4 地址。
        """
        return pulumi.get(self, "ipv4")

    @ipv4.setter
    def ipv4(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ipv4", value)


if not MYPY:
    class ClusterClusterConfigApiServerPublicAccessConfigArgsDict(TypedDict):
        public_access_network_config: NotRequired[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgsDict']]
        """
        公网访问网络配置。ApiServerPublicAccessEnable=true时才返回的参数。
        """
elif False:
    ClusterClusterConfigApiServerPublicAccessConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterClusterConfigApiServerPublicAccessConfigArgs:
    def __init__(__self__, *,
                 public_access_network_config: Optional[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs']] = None):
        """
        :param pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs'] public_access_network_config: 公网访问网络配置。ApiServerPublicAccessEnable=true时才返回的参数。
        """
        if public_access_network_config is not None:
            pulumi.set(__self__, "public_access_network_config", public_access_network_config)

    @property
    @pulumi.getter(name="publicAccessNetworkConfig")
    def public_access_network_config(self) -> Optional[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs']]:
        """
        公网访问网络配置。ApiServerPublicAccessEnable=true时才返回的参数。
        """
        return pulumi.get(self, "public_access_network_config")

    @public_access_network_config.setter
    def public_access_network_config(self, value: Optional[pulumi.Input['ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs']]):
        pulumi.set(self, "public_access_network_config", value)


if not MYPY:
    class ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        公网 IP 的带宽峰值，单位：Mbps。
        """
        billing_type: NotRequired[pulumi.Input[builtins.int]]
        """
        公网 IP 的计费类型：2：按量计费-按带宽上限。3：按量计费-按实际流量。
        """
        isp: NotRequired[pulumi.Input[builtins.str]]
        """
        公网 IP 的线路类型，参数值说明： BGP：BGP（多线）。
        """
elif False:
    ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterClusterConfigApiServerPublicAccessConfigPublicAccessNetworkConfigArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 billing_type: Optional[pulumi.Input[builtins.int]] = None,
                 isp: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: 公网 IP 的带宽峰值，单位：Mbps。
        :param pulumi.Input[builtins.int] billing_type: 公网 IP 的计费类型：2：按量计费-按带宽上限。3：按量计费-按实际流量。
        :param pulumi.Input[builtins.str] isp: 公网 IP 的线路类型，参数值说明： BGP：BGP（多线）。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if billing_type is not None:
            pulumi.set(__self__, "billing_type", billing_type)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网 IP 的带宽峰值，单位：Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @bandwidth.setter
    def bandwidth(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "bandwidth", value)

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网 IP 的计费类型：2：按量计费-按带宽上限。3：按量计费-按实际流量。
        """
        return pulumi.get(self, "billing_type")

    @billing_type.setter
    def billing_type(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "billing_type", value)

    @property
    @pulumi.getter
    def isp(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        公网 IP 的线路类型，参数值说明： BGP：BGP（多线）。
        """
        return pulumi.get(self, "isp")

    @isp.setter
    def isp(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "isp", value)


if not MYPY:
    class ClusterLoggingConfigArgsDict(TypedDict):
        log_project_id: NotRequired[pulumi.Input[builtins.str]]
        """
        集群的日志项目（Log Project）ID。 如果为空，表示集群的日志项目未被创建。
        """
        log_setups: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterLoggingConfigLogSetupArgsDict']]]]
elif False:
    ClusterLoggingConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLoggingConfigArgs:
    def __init__(__self__, *,
                 log_project_id: Optional[pulumi.Input[builtins.str]] = None,
                 log_setups: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterLoggingConfigLogSetupArgs']]]] = None):
        """
        :param pulumi.Input[builtins.str] log_project_id: 集群的日志项目（Log Project）ID。 如果为空，表示集群的日志项目未被创建。
        """
        if log_project_id is not None:
            pulumi.set(__self__, "log_project_id", log_project_id)
        if log_setups is not None:
            pulumi.set(__self__, "log_setups", log_setups)

    @property
    @pulumi.getter(name="logProjectId")
    def log_project_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        集群的日志项目（Log Project）ID。 如果为空，表示集群的日志项目未被创建。
        """
        return pulumi.get(self, "log_project_id")

    @log_project_id.setter
    def log_project_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "log_project_id", value)

    @property
    @pulumi.getter(name="logSetups")
    def log_setups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterLoggingConfigLogSetupArgs']]]]:
        return pulumi.get(self, "log_setups")

    @log_setups.setter
    def log_setups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterLoggingConfigLogSetupArgs']]]]):
        pulumi.set(self, "log_setups", value)


if not MYPY:
    class ClusterLoggingConfigLogSetupArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启该日志选项，参数值说明：true：已开启。false：未开启。
        """
        log_ttl: NotRequired[pulumi.Input[builtins.int]]
        """
        日志在日志服务中的保存时间，单位为天。 3650 天表示永久存储。
        """
        log_type: NotRequired[pulumi.Input[builtins.str]]
        """
        当前开启的日志类型，参数值说明：Audit：集群审计日志。KubeApiServer：kube-apiserver 组件日志。KubeScheduler：kube-scheduler 组件日志。KubeControllerManager：kube-controller-manager 组件日志。
        """
elif False:
    ClusterLoggingConfigLogSetupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLoggingConfigLogSetupArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 log_ttl: Optional[pulumi.Input[builtins.int]] = None,
                 log_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] enabled: 是否开启该日志选项，参数值说明：true：已开启。false：未开启。
        :param pulumi.Input[builtins.int] log_ttl: 日志在日志服务中的保存时间，单位为天。 3650 天表示永久存储。
        :param pulumi.Input[builtins.str] log_type: 当前开启的日志类型，参数值说明：Audit：集群审计日志。KubeApiServer：kube-apiserver 组件日志。KubeScheduler：kube-scheduler 组件日志。KubeControllerManager：kube-controller-manager 组件日志。
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if log_ttl is not None:
            pulumi.set(__self__, "log_ttl", log_ttl)
        if log_type is not None:
            pulumi.set(__self__, "log_type", log_type)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启该日志选项，参数值说明：true：已开启。false：未开启。
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="logTtl")
    def log_ttl(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        日志在日志服务中的保存时间，单位为天。 3650 天表示永久存储。
        """
        return pulumi.get(self, "log_ttl")

    @log_ttl.setter
    def log_ttl(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "log_ttl", value)

    @property
    @pulumi.getter(name="logType")
    def log_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        当前开启的日志类型，参数值说明：Audit：集群审计日志。KubeApiServer：kube-apiserver 组件日志。KubeScheduler：kube-scheduler 组件日志。KubeControllerManager：kube-controller-manager 组件日志。
        """
        return pulumi.get(self, "log_type")

    @log_type.setter
    def log_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "log_type", value)


if not MYPY:
    class ClusterMonitoringConfigArgsDict(TypedDict):
        component_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterMonitoringConfigComponentConfigArgsDict']]]]
        workspace_id: NotRequired[pulumi.Input[builtins.str]]
        """
        监控数据所属的工作区 ID。
        """
elif False:
    ClusterMonitoringConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterMonitoringConfigArgs:
    def __init__(__self__, *,
                 component_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterMonitoringConfigComponentConfigArgs']]]] = None,
                 workspace_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] workspace_id: 监控数据所属的工作区 ID。
        """
        if component_configs is not None:
            pulumi.set(__self__, "component_configs", component_configs)
        if workspace_id is not None:
            pulumi.set(__self__, "workspace_id", workspace_id)

    @property
    @pulumi.getter(name="componentConfigs")
    def component_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterMonitoringConfigComponentConfigArgs']]]]:
        return pulumi.get(self, "component_configs")

    @component_configs.setter
    def component_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterMonitoringConfigComponentConfigArgs']]]]):
        pulumi.set(self, "component_configs", value)

    @property
    @pulumi.getter(name="workspaceId")
    def workspace_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        监控数据所属的工作区 ID。
        """
        return pulumi.get(self, "workspace_id")

    @workspace_id.setter
    def workspace_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "workspace_id", value)


if not MYPY:
    class ClusterMonitoringConfigComponentConfigArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否启用该监控组件，true 表示启用，false 表示禁用。
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        监控组件的名称，例如 'prometheus'、'grafana' 等。
        """
elif False:
    ClusterMonitoringConfigComponentConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterMonitoringConfigComponentConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] enabled: 是否启用该监控组件，true 表示启用，false 表示禁用。
        :param pulumi.Input[builtins.str] name: 监控组件的名称，例如 'prometheus'、'grafana' 等。
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否启用该监控组件，true 表示启用，false 表示禁用。
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        监控组件的名称，例如 'prometheus'、'grafana' 等。
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)


if not MYPY:
    class ClusterNodeStatisticsArgsDict(TypedDict):
        creating_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Creating的节点总数量。
        """
        deleting_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Deleting的节点总数量。
        """
        failed_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Failed的节点总数量。
        """
        running_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Running的节点总数量。
        """
        total_count: NotRequired[pulumi.Input[builtins.int]]
        """
        节点总数量。
        """
        updating_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Updating的节点总数量。
        """
elif False:
    ClusterNodeStatisticsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterNodeStatisticsArgs:
    def __init__(__self__, *,
                 creating_count: Optional[pulumi.Input[builtins.int]] = None,
                 deleting_count: Optional[pulumi.Input[builtins.int]] = None,
                 failed_count: Optional[pulumi.Input[builtins.int]] = None,
                 running_count: Optional[pulumi.Input[builtins.int]] = None,
                 total_count: Optional[pulumi.Input[builtins.int]] = None,
                 updating_count: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] creating_count: Phase=Creating的节点总数量。
        :param pulumi.Input[builtins.int] deleting_count: Phase=Deleting的节点总数量。
        :param pulumi.Input[builtins.int] failed_count: Phase=Failed的节点总数量。
        :param pulumi.Input[builtins.int] running_count: Phase=Running的节点总数量。
        :param pulumi.Input[builtins.int] total_count: 节点总数量。
        :param pulumi.Input[builtins.int] updating_count: Phase=Updating的节点总数量。
        """
        if creating_count is not None:
            pulumi.set(__self__, "creating_count", creating_count)
        if deleting_count is not None:
            pulumi.set(__self__, "deleting_count", deleting_count)
        if failed_count is not None:
            pulumi.set(__self__, "failed_count", failed_count)
        if running_count is not None:
            pulumi.set(__self__, "running_count", running_count)
        if total_count is not None:
            pulumi.set(__self__, "total_count", total_count)
        if updating_count is not None:
            pulumi.set(__self__, "updating_count", updating_count)

    @property
    @pulumi.getter(name="creatingCount")
    def creating_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Creating的节点总数量。
        """
        return pulumi.get(self, "creating_count")

    @creating_count.setter
    def creating_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "creating_count", value)

    @property
    @pulumi.getter(name="deletingCount")
    def deleting_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Deleting的节点总数量。
        """
        return pulumi.get(self, "deleting_count")

    @deleting_count.setter
    def deleting_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "deleting_count", value)

    @property
    @pulumi.getter(name="failedCount")
    def failed_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Failed的节点总数量。
        """
        return pulumi.get(self, "failed_count")

    @failed_count.setter
    def failed_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "failed_count", value)

    @property
    @pulumi.getter(name="runningCount")
    def running_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Running的节点总数量。
        """
        return pulumi.get(self, "running_count")

    @running_count.setter
    def running_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "running_count", value)

    @property
    @pulumi.getter(name="totalCount")
    def total_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点总数量。
        """
        return pulumi.get(self, "total_count")

    @total_count.setter
    def total_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "total_count", value)

    @property
    @pulumi.getter(name="updatingCount")
    def updating_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Updating的节点总数量。
        """
        return pulumi.get(self, "updating_count")

    @updating_count.setter
    def updating_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "updating_count", value)


if not MYPY:
    class ClusterPodsConfigArgsDict(TypedDict):
        flannel_config: NotRequired[pulumi.Input['ClusterPodsConfigFlannelConfigArgsDict']]
        """
        Flannel 网络配置。
        """
        pod_network_mode: NotRequired[pulumi.Input[builtins.str]]
        """
        容器（Pod）网络模型（CNI），参数值说明：Flannel：Flannel 网络模型，独立的 Underlay 容器网络模型。VpcCniShared：VPC-CNI 网络模型，基于私有网络的弹性网卡 ENI 实现的 Underlay 容器网络模型。
        """
        vpc_cni_config: NotRequired[pulumi.Input['ClusterPodsConfigVpcCniConfigArgsDict']]
        """
        VPC-CNI 网络配置。
        """
elif False:
    ClusterPodsConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterPodsConfigArgs:
    def __init__(__self__, *,
                 flannel_config: Optional[pulumi.Input['ClusterPodsConfigFlannelConfigArgs']] = None,
                 pod_network_mode: Optional[pulumi.Input[builtins.str]] = None,
                 vpc_cni_config: Optional[pulumi.Input['ClusterPodsConfigVpcCniConfigArgs']] = None):
        """
        :param pulumi.Input['ClusterPodsConfigFlannelConfigArgs'] flannel_config: Flannel 网络配置。
        :param pulumi.Input[builtins.str] pod_network_mode: 容器（Pod）网络模型（CNI），参数值说明：Flannel：Flannel 网络模型，独立的 Underlay 容器网络模型。VpcCniShared：VPC-CNI 网络模型，基于私有网络的弹性网卡 ENI 实现的 Underlay 容器网络模型。
        :param pulumi.Input['ClusterPodsConfigVpcCniConfigArgs'] vpc_cni_config: VPC-CNI 网络配置。
        """
        if flannel_config is not None:
            pulumi.set(__self__, "flannel_config", flannel_config)
        if pod_network_mode is not None:
            pulumi.set(__self__, "pod_network_mode", pod_network_mode)
        if vpc_cni_config is not None:
            pulumi.set(__self__, "vpc_cni_config", vpc_cni_config)

    @property
    @pulumi.getter(name="flannelConfig")
    def flannel_config(self) -> Optional[pulumi.Input['ClusterPodsConfigFlannelConfigArgs']]:
        """
        Flannel 网络配置。
        """
        return pulumi.get(self, "flannel_config")

    @flannel_config.setter
    def flannel_config(self, value: Optional[pulumi.Input['ClusterPodsConfigFlannelConfigArgs']]):
        pulumi.set(self, "flannel_config", value)

    @property
    @pulumi.getter(name="podNetworkMode")
    def pod_network_mode(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        容器（Pod）网络模型（CNI），参数值说明：Flannel：Flannel 网络模型，独立的 Underlay 容器网络模型。VpcCniShared：VPC-CNI 网络模型，基于私有网络的弹性网卡 ENI 实现的 Underlay 容器网络模型。
        """
        return pulumi.get(self, "pod_network_mode")

    @pod_network_mode.setter
    def pod_network_mode(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "pod_network_mode", value)

    @property
    @pulumi.getter(name="vpcCniConfig")
    def vpc_cni_config(self) -> Optional[pulumi.Input['ClusterPodsConfigVpcCniConfigArgs']]:
        """
        VPC-CNI 网络配置。
        """
        return pulumi.get(self, "vpc_cni_config")

    @vpc_cni_config.setter
    def vpc_cni_config(self, value: Optional[pulumi.Input['ClusterPodsConfigVpcCniConfigArgs']]):
        pulumi.set(self, "vpc_cni_config", value)


if not MYPY:
    class ClusterPodsConfigFlannelConfigArgsDict(TypedDict):
        max_pods_per_node: NotRequired[pulumi.Input[builtins.int]]
        """
        Flannel 模型容器网络的单节点 Pod 实例数量上限，取值：64（默认值）、16、32、128、256。
        """
        pod_cidrs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Flannel 容器网络的 Pod CIDR。
        """
elif False:
    ClusterPodsConfigFlannelConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterPodsConfigFlannelConfigArgs:
    def __init__(__self__, *,
                 max_pods_per_node: Optional[pulumi.Input[builtins.int]] = None,
                 pod_cidrs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.int] max_pods_per_node: Flannel 模型容器网络的单节点 Pod 实例数量上限，取值：64（默认值）、16、32、128、256。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] pod_cidrs: Flannel 容器网络的 Pod CIDR。
        """
        if max_pods_per_node is not None:
            pulumi.set(__self__, "max_pods_per_node", max_pods_per_node)
        if pod_cidrs is not None:
            pulumi.set(__self__, "pod_cidrs", pod_cidrs)

    @property
    @pulumi.getter(name="maxPodsPerNode")
    def max_pods_per_node(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Flannel 模型容器网络的单节点 Pod 实例数量上限，取值：64（默认值）、16、32、128、256。
        """
        return pulumi.get(self, "max_pods_per_node")

    @max_pods_per_node.setter
    def max_pods_per_node(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "max_pods_per_node", value)

    @property
    @pulumi.getter(name="podCidrs")
    def pod_cidrs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Flannel 容器网络的 Pod CIDR。
        """
        return pulumi.get(self, "pod_cidrs")

    @pod_cidrs.setter
    def pod_cidrs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "pod_cidrs", value)


if not MYPY:
    class ClusterPodsConfigVpcCniConfigArgsDict(TypedDict):
        subnet_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        VPC-CNI 容器网络模型对应的 Pod 子网 ID 列表。
        """
        trunk_eni_enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启 VPC-CNI 容器网络模型的 Trunk 模式。
        """
elif False:
    ClusterPodsConfigVpcCniConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterPodsConfigVpcCniConfigArgs:
    def __init__(__self__, *,
                 subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 trunk_eni_enabled: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] subnet_ids: VPC-CNI 容器网络模型对应的 Pod 子网 ID 列表。
        :param pulumi.Input[builtins.bool] trunk_eni_enabled: 是否开启 VPC-CNI 容器网络模型的 Trunk 模式。
        """
        if subnet_ids is not None:
            pulumi.set(__self__, "subnet_ids", subnet_ids)
        if trunk_eni_enabled is not None:
            pulumi.set(__self__, "trunk_eni_enabled", trunk_eni_enabled)

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        VPC-CNI 容器网络模型对应的 Pod 子网 ID 列表。
        """
        return pulumi.get(self, "subnet_ids")

    @subnet_ids.setter
    def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "subnet_ids", value)

    @property
    @pulumi.getter(name="trunkEniEnabled")
    def trunk_eni_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启 VPC-CNI 容器网络模型的 Trunk 模式。
        """
        return pulumi.get(self, "trunk_eni_enabled")

    @trunk_eni_enabled.setter
    def trunk_eni_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "trunk_eni_enabled", value)


if not MYPY:
    class ClusterServicesConfigArgsDict(TypedDict):
        service_cidrsv4s: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        Kubernetes 服务（Service）暴露的 IPv4 私有网络地址。
        """
elif False:
    ClusterServicesConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterServicesConfigArgs:
    def __init__(__self__, *,
                 service_cidrsv4s: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] service_cidrsv4s: Kubernetes 服务（Service）暴露的 IPv4 私有网络地址。
        """
        if service_cidrsv4s is not None:
            pulumi.set(__self__, "service_cidrsv4s", service_cidrsv4s)

    @property
    @pulumi.getter(name="serviceCidrsv4s")
    def service_cidrsv4s(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        Kubernetes 服务（Service）暴露的 IPv4 私有网络地址。
        """
        return pulumi.get(self, "service_cidrsv4s")

    @service_cidrsv4s.setter
    def service_cidrsv4s(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "service_cidrsv4s", value)


if not MYPY:
    class ClusterStatusArgsDict(TypedDict):
        conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterStatusConditionArgsDict']]]]
        phase: NotRequired[pulumi.Input[builtins.str]]
        """
        集群状态阶段
        """
elif False:
    ClusterStatusArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterStatusArgs:
    def __init__(__self__, *,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterStatusConditionArgs']]]] = None,
                 phase: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] phase: 集群状态阶段
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if phase is not None:
            pulumi.set(__self__, "phase", phase)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClusterStatusConditionArgs']]]]:
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterStatusConditionArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def phase(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        集群状态阶段
        """
        return pulumi.get(self, "phase")

    @phase.setter
    def phase(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "phase", value)


if not MYPY:
    class ClusterStatusConditionArgsDict(TypedDict):
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        条件类型
        """
elif False:
    ClusterStatusConditionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterStatusConditionArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] type: 条件类型
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        条件类型
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class ClusterTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签值。
        """
elif False:
    ClusterTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签键。
        :param pulumi.Input[builtins.str] value: 标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签值。
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class NodePoolAutoScalingArgsDict(TypedDict):
        desired_replicas: NotRequired[pulumi.Input[builtins.int]]
        """
        配置节点池的期望节点数。
        """
        enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        配置节点池弹性伸缩功能开关，参数值说明：false：关闭。true：开启。
        """
        max_replicas: NotRequired[pulumi.Input[builtins.int]]
        """
        配置节点池的最大节点数。
        """
        min_replicas: NotRequired[pulumi.Input[builtins.int]]
        """
        配置节点池的最小节点数。
        """
        priority: NotRequired[pulumi.Input[builtins.int]]
        """
        优先级。
        """
        scaling_group_id: NotRequired[pulumi.Input[builtins.str]]
        """
        伸缩组ID。
        """
        subnet_policy: NotRequired[pulumi.Input[builtins.str]]
        """
        节点池的多子网调度策略，参数值说明：ZoneBalance：可用区均衡策略。Priority：子网优先级策略。
        """
elif False:
    NodePoolAutoScalingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolAutoScalingArgs:
    def __init__(__self__, *,
                 desired_replicas: Optional[pulumi.Input[builtins.int]] = None,
                 enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 max_replicas: Optional[pulumi.Input[builtins.int]] = None,
                 min_replicas: Optional[pulumi.Input[builtins.int]] = None,
                 priority: Optional[pulumi.Input[builtins.int]] = None,
                 scaling_group_id: Optional[pulumi.Input[builtins.str]] = None,
                 subnet_policy: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] desired_replicas: 配置节点池的期望节点数。
        :param pulumi.Input[builtins.bool] enabled: 配置节点池弹性伸缩功能开关，参数值说明：false：关闭。true：开启。
        :param pulumi.Input[builtins.int] max_replicas: 配置节点池的最大节点数。
        :param pulumi.Input[builtins.int] min_replicas: 配置节点池的最小节点数。
        :param pulumi.Input[builtins.int] priority: 优先级。
        :param pulumi.Input[builtins.str] scaling_group_id: 伸缩组ID。
        :param pulumi.Input[builtins.str] subnet_policy: 节点池的多子网调度策略，参数值说明：ZoneBalance：可用区均衡策略。Priority：子网优先级策略。
        """
        if desired_replicas is not None:
            pulumi.set(__self__, "desired_replicas", desired_replicas)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if max_replicas is not None:
            pulumi.set(__self__, "max_replicas", max_replicas)
        if min_replicas is not None:
            pulumi.set(__self__, "min_replicas", min_replicas)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if scaling_group_id is not None:
            pulumi.set(__self__, "scaling_group_id", scaling_group_id)
        if subnet_policy is not None:
            pulumi.set(__self__, "subnet_policy", subnet_policy)

    @property
    @pulumi.getter(name="desiredReplicas")
    def desired_replicas(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        配置节点池的期望节点数。
        """
        return pulumi.get(self, "desired_replicas")

    @desired_replicas.setter
    def desired_replicas(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "desired_replicas", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        配置节点池弹性伸缩功能开关，参数值说明：false：关闭。true：开启。
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="maxReplicas")
    def max_replicas(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        配置节点池的最大节点数。
        """
        return pulumi.get(self, "max_replicas")

    @max_replicas.setter
    def max_replicas(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "max_replicas", value)

    @property
    @pulumi.getter(name="minReplicas")
    def min_replicas(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        配置节点池的最小节点数。
        """
        return pulumi.get(self, "min_replicas")

    @min_replicas.setter
    def min_replicas(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "min_replicas", value)

    @property
    @pulumi.getter
    def priority(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        优先级。
        """
        return pulumi.get(self, "priority")

    @priority.setter
    def priority(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "priority", value)

    @property
    @pulumi.getter(name="scalingGroupId")
    def scaling_group_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        伸缩组ID。
        """
        return pulumi.get(self, "scaling_group_id")

    @scaling_group_id.setter
    def scaling_group_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "scaling_group_id", value)

    @property
    @pulumi.getter(name="subnetPolicy")
    def subnet_policy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点池的多子网调度策略，参数值说明：ZoneBalance：可用区均衡策略。Priority：子网优先级策略。
        """
        return pulumi.get(self, "subnet_policy")

    @subnet_policy.setter
    def subnet_policy(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "subnet_policy", value)


if not MYPY:
    class NodePoolKubernetesConfigArgsDict(TypedDict):
        auto_sync_disabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否禁用自动同步标签污点到存量节点的功能，参数值说明：true：禁用，即关闭自动同步。false：不禁用，即开启自动同步。
        """
        cordon: NotRequired[pulumi.Input[builtins.bool]]
        """
        封锁节点配置，参数值说明：false：不封锁。true：封锁。
        """
        kubelet_config: NotRequired[pulumi.Input['NodePoolKubernetesConfigKubeletConfigArgsDict']]
        """
        Kubelet 组件的相关配置
        """
        labels: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigLabelArgsDict']]]]
        name_prefix: NotRequired[pulumi.Input[builtins.str]]
        """
        Kubernetes 中节点对象的元数据名称前缀。
        """
        name_suffix: NotRequired[pulumi.Input[builtins.str]]
        """
        Kubernetes 中节点对象的元数据名称后缀。
        """
        name_use_hostname: NotRequired[pulumi.Input[builtins.bool]]
        """
        Kubernetes 中节点对象的元数据名称是否使用 ECS 主机名称，取值：true：使用 ECS 主机名称作为节点名称。false：不使用使用 ECS 主机名称作为节点名称。
        """
        taints: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigTaintArgsDict']]]]
elif False:
    NodePoolKubernetesConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolKubernetesConfigArgs:
    def __init__(__self__, *,
                 auto_sync_disabled: Optional[pulumi.Input[builtins.bool]] = None,
                 cordon: Optional[pulumi.Input[builtins.bool]] = None,
                 kubelet_config: Optional[pulumi.Input['NodePoolKubernetesConfigKubeletConfigArgs']] = None,
                 labels: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigLabelArgs']]]] = None,
                 name_prefix: Optional[pulumi.Input[builtins.str]] = None,
                 name_suffix: Optional[pulumi.Input[builtins.str]] = None,
                 name_use_hostname: Optional[pulumi.Input[builtins.bool]] = None,
                 taints: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigTaintArgs']]]] = None):
        """
        :param pulumi.Input[builtins.bool] auto_sync_disabled: 是否禁用自动同步标签污点到存量节点的功能，参数值说明：true：禁用，即关闭自动同步。false：不禁用，即开启自动同步。
        :param pulumi.Input[builtins.bool] cordon: 封锁节点配置，参数值说明：false：不封锁。true：封锁。
        :param pulumi.Input['NodePoolKubernetesConfigKubeletConfigArgs'] kubelet_config: Kubelet 组件的相关配置
        :param pulumi.Input[builtins.str] name_prefix: Kubernetes 中节点对象的元数据名称前缀。
        :param pulumi.Input[builtins.str] name_suffix: Kubernetes 中节点对象的元数据名称后缀。
        :param pulumi.Input[builtins.bool] name_use_hostname: Kubernetes 中节点对象的元数据名称是否使用 ECS 主机名称，取值：true：使用 ECS 主机名称作为节点名称。false：不使用使用 ECS 主机名称作为节点名称。
        """
        if auto_sync_disabled is not None:
            pulumi.set(__self__, "auto_sync_disabled", auto_sync_disabled)
        if cordon is not None:
            pulumi.set(__self__, "cordon", cordon)
        if kubelet_config is not None:
            pulumi.set(__self__, "kubelet_config", kubelet_config)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if name_prefix is not None:
            pulumi.set(__self__, "name_prefix", name_prefix)
        if name_suffix is not None:
            pulumi.set(__self__, "name_suffix", name_suffix)
        if name_use_hostname is not None:
            pulumi.set(__self__, "name_use_hostname", name_use_hostname)
        if taints is not None:
            pulumi.set(__self__, "taints", taints)

    @property
    @pulumi.getter(name="autoSyncDisabled")
    def auto_sync_disabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否禁用自动同步标签污点到存量节点的功能，参数值说明：true：禁用，即关闭自动同步。false：不禁用，即开启自动同步。
        """
        return pulumi.get(self, "auto_sync_disabled")

    @auto_sync_disabled.setter
    def auto_sync_disabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "auto_sync_disabled", value)

    @property
    @pulumi.getter
    def cordon(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        封锁节点配置，参数值说明：false：不封锁。true：封锁。
        """
        return pulumi.get(self, "cordon")

    @cordon.setter
    def cordon(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "cordon", value)

    @property
    @pulumi.getter(name="kubeletConfig")
    def kubelet_config(self) -> Optional[pulumi.Input['NodePoolKubernetesConfigKubeletConfigArgs']]:
        """
        Kubelet 组件的相关配置
        """
        return pulumi.get(self, "kubelet_config")

    @kubelet_config.setter
    def kubelet_config(self, value: Optional[pulumi.Input['NodePoolKubernetesConfigKubeletConfigArgs']]):
        pulumi.set(self, "kubelet_config", value)

    @property
    @pulumi.getter
    def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigLabelArgs']]]]:
        return pulumi.get(self, "labels")

    @labels.setter
    def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigLabelArgs']]]]):
        pulumi.set(self, "labels", value)

    @property
    @pulumi.getter(name="namePrefix")
    def name_prefix(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Kubernetes 中节点对象的元数据名称前缀。
        """
        return pulumi.get(self, "name_prefix")

    @name_prefix.setter
    def name_prefix(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name_prefix", value)

    @property
    @pulumi.getter(name="nameSuffix")
    def name_suffix(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Kubernetes 中节点对象的元数据名称后缀。
        """
        return pulumi.get(self, "name_suffix")

    @name_suffix.setter
    def name_suffix(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name_suffix", value)

    @property
    @pulumi.getter(name="nameUseHostname")
    def name_use_hostname(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Kubernetes 中节点对象的元数据名称是否使用 ECS 主机名称，取值：true：使用 ECS 主机名称作为节点名称。false：不使用使用 ECS 主机名称作为节点名称。
        """
        return pulumi.get(self, "name_use_hostname")

    @name_use_hostname.setter
    def name_use_hostname(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "name_use_hostname", value)

    @property
    @pulumi.getter
    def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigTaintArgs']]]]:
        return pulumi.get(self, "taints")

    @taints.setter
    def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigTaintArgs']]]]):
        pulumi.set(self, "taints", value)


if not MYPY:
    class NodePoolKubernetesConfigKubeletConfigArgsDict(TypedDict):
        cpu_manager_policy: NotRequired[pulumi.Input[builtins.str]]
        """
        配置 kubelet 的 CpuManagerPolicy 策略，包含 none 和 static 两种策略
        """
        feature_gates: NotRequired[pulumi.Input['NodePoolKubernetesConfigKubeletConfigFeatureGatesArgsDict']]
        """
        特性门控。
        """
        kube_api_burst: NotRequired[pulumi.Input[builtins.int]]
        """
        每秒发送到 API 服务器的突发请求数量上限。不包括事件和节点心跳 API，其速率限制由一组不同的标志控制。
        """
        kube_api_qps: NotRequired[pulumi.Input[builtins.int]]
        """
        与 apiserver 通信的每秒查询个数（QPS）。不包含事件和节点心跳 API，它们的速率限制是由一组不同的标志所控制。
        """
        kube_reserveds: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigKubeReservedArgsDict']]]]
        max_pods: NotRequired[pulumi.Input[builtins.int]]
        """
        配置 kubelet 支持的最大 Pod 数量
        """
        registry_burst: NotRequired[pulumi.Input[builtins.int]]
        """
        设置突发性镜像拉取的个数上限，在不超过 RegistryPullQps 设置值的前提下暂时允许此参数所给的镜像拉取个数。
        """
        registry_pull_qps: NotRequired[pulumi.Input[builtins.int]]
        """
        可用来限制镜像仓库的 QPS 上限
        """
        serialize_image_pulls: NotRequired[pulumi.Input[builtins.bool]]
        """
        逐一拉取镜像。
        """
        system_reserveds: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigSystemReservedArgsDict']]]]
        topology_manager_policy: NotRequired[pulumi.Input[builtins.str]]
        """
        拓扑管理策略，取值：none：（默认）禁用拓扑管理策略。restricted：kubelet 仅接受在所请求资源上实现最佳 NUMA（Non-Uniform Memory Access，非一致存储访问结构）的 Pod。best-effort：kubelet 会优先选择在 CPU 和设备资源上实现 NUMA 的 Pod。single-numa-node：kubelet 仅允许在同一个节点的 CPU 和设备资源上实现 NUMA 的 Pod。
        """
        topology_manager_scope: NotRequired[pulumi.Input[builtins.str]]
        """
        拓扑管理策略的资源粒度，取值：container：表示资源对齐粒度为容器级。pod：表示资源对齐粒度为 Pod 级。
        """
elif False:
    NodePoolKubernetesConfigKubeletConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolKubernetesConfigKubeletConfigArgs:
    def __init__(__self__, *,
                 cpu_manager_policy: Optional[pulumi.Input[builtins.str]] = None,
                 feature_gates: Optional[pulumi.Input['NodePoolKubernetesConfigKubeletConfigFeatureGatesArgs']] = None,
                 kube_api_burst: Optional[pulumi.Input[builtins.int]] = None,
                 kube_api_qps: Optional[pulumi.Input[builtins.int]] = None,
                 kube_reserveds: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigKubeReservedArgs']]]] = None,
                 max_pods: Optional[pulumi.Input[builtins.int]] = None,
                 registry_burst: Optional[pulumi.Input[builtins.int]] = None,
                 registry_pull_qps: Optional[pulumi.Input[builtins.int]] = None,
                 serialize_image_pulls: Optional[pulumi.Input[builtins.bool]] = None,
                 system_reserveds: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigSystemReservedArgs']]]] = None,
                 topology_manager_policy: Optional[pulumi.Input[builtins.str]] = None,
                 topology_manager_scope: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] cpu_manager_policy: 配置 kubelet 的 CpuManagerPolicy 策略，包含 none 和 static 两种策略
        :param pulumi.Input['NodePoolKubernetesConfigKubeletConfigFeatureGatesArgs'] feature_gates: 特性门控。
        :param pulumi.Input[builtins.int] kube_api_burst: 每秒发送到 API 服务器的突发请求数量上限。不包括事件和节点心跳 API，其速率限制由一组不同的标志控制。
        :param pulumi.Input[builtins.int] kube_api_qps: 与 apiserver 通信的每秒查询个数（QPS）。不包含事件和节点心跳 API，它们的速率限制是由一组不同的标志所控制。
        :param pulumi.Input[builtins.int] max_pods: 配置 kubelet 支持的最大 Pod 数量
        :param pulumi.Input[builtins.int] registry_burst: 设置突发性镜像拉取的个数上限，在不超过 RegistryPullQps 设置值的前提下暂时允许此参数所给的镜像拉取个数。
        :param pulumi.Input[builtins.int] registry_pull_qps: 可用来限制镜像仓库的 QPS 上限
        :param pulumi.Input[builtins.bool] serialize_image_pulls: 逐一拉取镜像。
        :param pulumi.Input[builtins.str] topology_manager_policy: 拓扑管理策略，取值：none：（默认）禁用拓扑管理策略。restricted：kubelet 仅接受在所请求资源上实现最佳 NUMA（Non-Uniform Memory Access，非一致存储访问结构）的 Pod。best-effort：kubelet 会优先选择在 CPU 和设备资源上实现 NUMA 的 Pod。single-numa-node：kubelet 仅允许在同一个节点的 CPU 和设备资源上实现 NUMA 的 Pod。
        :param pulumi.Input[builtins.str] topology_manager_scope: 拓扑管理策略的资源粒度，取值：container：表示资源对齐粒度为容器级。pod：表示资源对齐粒度为 Pod 级。
        """
        if cpu_manager_policy is not None:
            pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
        if feature_gates is not None:
            pulumi.set(__self__, "feature_gates", feature_gates)
        if kube_api_burst is not None:
            pulumi.set(__self__, "kube_api_burst", kube_api_burst)
        if kube_api_qps is not None:
            pulumi.set(__self__, "kube_api_qps", kube_api_qps)
        if kube_reserveds is not None:
            pulumi.set(__self__, "kube_reserveds", kube_reserveds)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if registry_burst is not None:
            pulumi.set(__self__, "registry_burst", registry_burst)
        if registry_pull_qps is not None:
            pulumi.set(__self__, "registry_pull_qps", registry_pull_qps)
        if serialize_image_pulls is not None:
            pulumi.set(__self__, "serialize_image_pulls", serialize_image_pulls)
        if system_reserveds is not None:
            pulumi.set(__self__, "system_reserveds", system_reserveds)
        if topology_manager_policy is not None:
            pulumi.set(__self__, "topology_manager_policy", topology_manager_policy)
        if topology_manager_scope is not None:
            pulumi.set(__self__, "topology_manager_scope", topology_manager_scope)

    @property
    @pulumi.getter(name="cpuManagerPolicy")
    def cpu_manager_policy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        配置 kubelet 的 CpuManagerPolicy 策略，包含 none 和 static 两种策略
        """
        return pulumi.get(self, "cpu_manager_policy")

    @cpu_manager_policy.setter
    def cpu_manager_policy(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "cpu_manager_policy", value)

    @property
    @pulumi.getter(name="featureGates")
    def feature_gates(self) -> Optional[pulumi.Input['NodePoolKubernetesConfigKubeletConfigFeatureGatesArgs']]:
        """
        特性门控。
        """
        return pulumi.get(self, "feature_gates")

    @feature_gates.setter
    def feature_gates(self, value: Optional[pulumi.Input['NodePoolKubernetesConfigKubeletConfigFeatureGatesArgs']]):
        pulumi.set(self, "feature_gates", value)

    @property
    @pulumi.getter(name="kubeApiBurst")
    def kube_api_burst(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        每秒发送到 API 服务器的突发请求数量上限。不包括事件和节点心跳 API，其速率限制由一组不同的标志控制。
        """
        return pulumi.get(self, "kube_api_burst")

    @kube_api_burst.setter
    def kube_api_burst(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "kube_api_burst", value)

    @property
    @pulumi.getter(name="kubeApiQps")
    def kube_api_qps(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        与 apiserver 通信的每秒查询个数（QPS）。不包含事件和节点心跳 API，它们的速率限制是由一组不同的标志所控制。
        """
        return pulumi.get(self, "kube_api_qps")

    @kube_api_qps.setter
    def kube_api_qps(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "kube_api_qps", value)

    @property
    @pulumi.getter(name="kubeReserveds")
    def kube_reserveds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigKubeReservedArgs']]]]:
        return pulumi.get(self, "kube_reserveds")

    @kube_reserveds.setter
    def kube_reserveds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigKubeReservedArgs']]]]):
        pulumi.set(self, "kube_reserveds", value)

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        配置 kubelet 支持的最大 Pod 数量
        """
        return pulumi.get(self, "max_pods")

    @max_pods.setter
    def max_pods(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "max_pods", value)

    @property
    @pulumi.getter(name="registryBurst")
    def registry_burst(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        设置突发性镜像拉取的个数上限，在不超过 RegistryPullQps 设置值的前提下暂时允许此参数所给的镜像拉取个数。
        """
        return pulumi.get(self, "registry_burst")

    @registry_burst.setter
    def registry_burst(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "registry_burst", value)

    @property
    @pulumi.getter(name="registryPullQps")
    def registry_pull_qps(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        可用来限制镜像仓库的 QPS 上限
        """
        return pulumi.get(self, "registry_pull_qps")

    @registry_pull_qps.setter
    def registry_pull_qps(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "registry_pull_qps", value)

    @property
    @pulumi.getter(name="serializeImagePulls")
    def serialize_image_pulls(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        逐一拉取镜像。
        """
        return pulumi.get(self, "serialize_image_pulls")

    @serialize_image_pulls.setter
    def serialize_image_pulls(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "serialize_image_pulls", value)

    @property
    @pulumi.getter(name="systemReserveds")
    def system_reserveds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigSystemReservedArgs']]]]:
        return pulumi.get(self, "system_reserveds")

    @system_reserveds.setter
    def system_reserveds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolKubernetesConfigKubeletConfigSystemReservedArgs']]]]):
        pulumi.set(self, "system_reserveds", value)

    @property
    @pulumi.getter(name="topologyManagerPolicy")
    def topology_manager_policy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        拓扑管理策略，取值：none：（默认）禁用拓扑管理策略。restricted：kubelet 仅接受在所请求资源上实现最佳 NUMA（Non-Uniform Memory Access，非一致存储访问结构）的 Pod。best-effort：kubelet 会优先选择在 CPU 和设备资源上实现 NUMA 的 Pod。single-numa-node：kubelet 仅允许在同一个节点的 CPU 和设备资源上实现 NUMA 的 Pod。
        """
        return pulumi.get(self, "topology_manager_policy")

    @topology_manager_policy.setter
    def topology_manager_policy(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "topology_manager_policy", value)

    @property
    @pulumi.getter(name="topologyManagerScope")
    def topology_manager_scope(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        拓扑管理策略的资源粒度，取值：container：表示资源对齐粒度为容器级。pod：表示资源对齐粒度为 Pod 级。
        """
        return pulumi.get(self, "topology_manager_scope")

    @topology_manager_scope.setter
    def topology_manager_scope(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "topology_manager_scope", value)


if not MYPY:
    class NodePoolKubernetesConfigKubeletConfigFeatureGatesArgsDict(TypedDict):
        in_place_pod_vertical_scaling: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启特性开关本地垂直Pod伸缩
        """
        qo_s_resource_manager: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启 QoSResourceManager特性开关，取值：  - true 开启。  - false 关闭。
        """
elif False:
    NodePoolKubernetesConfigKubeletConfigFeatureGatesArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolKubernetesConfigKubeletConfigFeatureGatesArgs:
    def __init__(__self__, *,
                 in_place_pod_vertical_scaling: Optional[pulumi.Input[builtins.bool]] = None,
                 qo_s_resource_manager: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[builtins.bool] in_place_pod_vertical_scaling: 是否开启特性开关本地垂直Pod伸缩
        :param pulumi.Input[builtins.bool] qo_s_resource_manager: 是否开启 QoSResourceManager特性开关，取值：  - true 开启。  - false 关闭。
        """
        if in_place_pod_vertical_scaling is not None:
            pulumi.set(__self__, "in_place_pod_vertical_scaling", in_place_pod_vertical_scaling)
        if qo_s_resource_manager is not None:
            pulumi.set(__self__, "qo_s_resource_manager", qo_s_resource_manager)

    @property
    @pulumi.getter(name="inPlacePodVerticalScaling")
    def in_place_pod_vertical_scaling(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启特性开关本地垂直Pod伸缩
        """
        return pulumi.get(self, "in_place_pod_vertical_scaling")

    @in_place_pod_vertical_scaling.setter
    def in_place_pod_vertical_scaling(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "in_place_pod_vertical_scaling", value)

    @property
    @pulumi.getter(name="qoSResourceManager")
    def qo_s_resource_manager(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启 QoSResourceManager特性开关，取值：  - true 开启。  - false 关闭。
        """
        return pulumi.get(self, "qo_s_resource_manager")

    @qo_s_resource_manager.setter
    def qo_s_resource_manager(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "qo_s_resource_manager", value)


if not MYPY:
    class NodePoolKubernetesConfigKubeletConfigKubeReservedArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        资源名称，取值为 cpu 或 memory。
        """
        quantity: NotRequired[pulumi.Input[builtins.str]]
        """
        指定资源的资源量。   - 当资源为 cpu 时，取值示例为 200m。   - 当资源为 memory 时，取值示例为 1G
        """
elif False:
    NodePoolKubernetesConfigKubeletConfigKubeReservedArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolKubernetesConfigKubeletConfigKubeReservedArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 quantity: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: 资源名称，取值为 cpu 或 memory。
        :param pulumi.Input[builtins.str] quantity: 指定资源的资源量。   - 当资源为 cpu 时，取值示例为 200m。   - 当资源为 memory 时，取值示例为 1G
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        资源名称，取值为 cpu 或 memory。
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def quantity(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        指定资源的资源量。   - 当资源为 cpu 时，取值示例为 200m。   - 当资源为 memory 时，取值示例为 1G
        """
        return pulumi.get(self, "quantity")

    @quantity.setter
    def quantity(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "quantity", value)


if not MYPY:
    class NodePoolKubernetesConfigKubeletConfigSystemReservedArgsDict(TypedDict):
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        资源名称，取值为 cpu 或 memory。
        """
        quantity: NotRequired[pulumi.Input[builtins.str]]
        """
        指定资源的资源量。   - 当资源为 cpu 时，取值示例为 200m。   - 当资源为 memory 时，取值示例为 1G。
        """
elif False:
    NodePoolKubernetesConfigKubeletConfigSystemReservedArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolKubernetesConfigKubeletConfigSystemReservedArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 quantity: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] name: 资源名称，取值为 cpu 或 memory。
        :param pulumi.Input[builtins.str] quantity: 指定资源的资源量。   - 当资源为 cpu 时，取值示例为 200m。   - 当资源为 memory 时，取值示例为 1G。
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        资源名称，取值为 cpu 或 memory。
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def quantity(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        指定资源的资源量。   - 当资源为 cpu 时，取值示例为 200m。   - 当资源为 memory 时，取值示例为 1G。
        """
        return pulumi.get(self, "quantity")

    @quantity.setter
    def quantity(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "quantity", value)


if not MYPY:
    class NodePoolKubernetesConfigLabelArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签值。
        """
elif False:
    NodePoolKubernetesConfigLabelArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolKubernetesConfigLabelArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签键。
        :param pulumi.Input[builtins.str] value: 标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签值。
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class NodePoolKubernetesConfigTaintArgsDict(TypedDict):
        effect: NotRequired[pulumi.Input[builtins.str]]
        """
        污点效果，取值：NoSchedule：（默认值）不调度。NoExecute：驱逐没有容忍污点的 Pod。PreferNoSchedule：尽量避免调度。
        """
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        污点键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        污点值。
        """
elif False:
    NodePoolKubernetesConfigTaintArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolKubernetesConfigTaintArgs:
    def __init__(__self__, *,
                 effect: Optional[pulumi.Input[builtins.str]] = None,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] effect: 污点效果，取值：NoSchedule：（默认值）不调度。NoExecute：驱逐没有容忍污点的 Pod。PreferNoSchedule：尽量避免调度。
        :param pulumi.Input[builtins.str] key: 污点键。
        :param pulumi.Input[builtins.str] value: 污点值。
        """
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        污点效果，取值：NoSchedule：（默认值）不调度。NoExecute：驱逐没有容忍污点的 Pod。PreferNoSchedule：尽量避免调度。
        """
        return pulumi.get(self, "effect")

    @effect.setter
    def effect(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "effect", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        污点键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        污点值。
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class NodePoolManagementArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        节点池是否开启托管。取值：  - true：开启。  - false：关闭。。
        """
        remedy_config: NotRequired[pulumi.Input['NodePoolManagementRemedyConfigArgsDict']]
        """
        检查自愈配置。
        """
elif False:
    NodePoolManagementArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolManagementArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 remedy_config: Optional[pulumi.Input['NodePoolManagementRemedyConfigArgs']] = None):
        """
        :param pulumi.Input[builtins.bool] enabled: 节点池是否开启托管。取值：  - true：开启。  - false：关闭。。
        :param pulumi.Input['NodePoolManagementRemedyConfigArgs'] remedy_config: 检查自愈配置。
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if remedy_config is not None:
            pulumi.set(__self__, "remedy_config", remedy_config)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        节点池是否开启托管。取值：  - true：开启。  - false：关闭。。
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="remedyConfig")
    def remedy_config(self) -> Optional[pulumi.Input['NodePoolManagementRemedyConfigArgs']]:
        """
        检查自愈配置。
        """
        return pulumi.get(self, "remedy_config")

    @remedy_config.setter
    def remedy_config(self, value: Optional[pulumi.Input['NodePoolManagementRemedyConfigArgs']]):
        pulumi.set(self, "remedy_config", value)


if not MYPY:
    class NodePoolManagementRemedyConfigArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启检查自愈。
        """
        remedy_id: NotRequired[pulumi.Input[builtins.str]]
        """
        检查自愈规则ID。
        """
elif False:
    NodePoolManagementRemedyConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolManagementRemedyConfigArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 remedy_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] enabled: 是否开启检查自愈。
        :param pulumi.Input[builtins.str] remedy_id: 检查自愈规则ID。
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if remedy_id is not None:
            pulumi.set(__self__, "remedy_id", remedy_id)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启检查自愈。
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="remedyId")
    def remedy_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        检查自愈规则ID。
        """
        return pulumi.get(self, "remedy_id")

    @remedy_id.setter
    def remedy_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "remedy_id", value)


if not MYPY:
    class NodePoolNodeConfigArgsDict(TypedDict):
        additional_container_storage_enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        节点的第一块数据盘是否已配置并格式化挂载作为容器镜像和日志的存储目录，参数值说明：false：未配置并格式化。true：已配置并格式化。
        """
        auto_renew: NotRequired[pulumi.Input[builtins.bool]]
        """
        云服务器实例到期是否自动续费，参数值说明：true：自动续费false：不自动续费仅当InstanceChargeType=PrePaid时才返回的参数。
        """
        auto_renew_period: NotRequired[pulumi.Input[builtins.int]]
        """
        云服务器实例每次自动续费时长，单位为月。仅当AutoRenew=true时才返回的参数。
        """
        data_volumes: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigDataVolumeArgsDict']]]]
        deployment_set_group_number: NotRequired[pulumi.Input[builtins.int]]
        """
        实例在部署集中的分组号，0表示未设置
        """
        deployment_set_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例需要加入的部署集ID
        """
        hostname: NotRequired[pulumi.Input[builtins.str]]
        """
        节点对应的主机名称。
        """
        hpc_cluster_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        高性能计算集群 ID。当节点池配置为高性能计算 GPU 型规格节点时，返回高性能计算集群 ID。
        """
        image_id: NotRequired[pulumi.Input[builtins.str]]
        """
        节点对应云服务器所使用的镜像 ID。
        """
        initialize_script: NotRequired[pulumi.Input[builtins.str]]
        """
        创建并初始化节点后执行的自定义脚本。Base64 编码后的 Shell 格式脚本。
        """
        instance_charge_type: NotRequired[pulumi.Input[builtins.str]]
        """
        云服务器实例计费类型，参数值说明：PostPaid：按量计费PrePaid：包年包月
        """
        instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点（实例）名称。
        """
        instance_type_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点对应的云服务器实例规格 ID 列表。
        """
        instances_distribution: NotRequired[pulumi.Input['NodePoolNodeConfigInstancesDistributionArgsDict']]
        """
        设置抢占式实例和按量实例的混合策略。当SpotStrategy为SpotAsPriceGo时，该策略生效。。
        """
        name_prefix: NotRequired[pulumi.Input[builtins.str]]
        """
        节点名称前缀，为空字符串或 nil 时表示未开启节点名称前缀策略。
        """
        network_traffic_mode: NotRequired[pulumi.Input[builtins.str]]
        """
        节点间的网络通讯模式。
        """
        period: NotRequired[pulumi.Input[builtins.int]]
        """
        云服务器实例购买时长，单位为月。仅当InstanceChargeType=PrePaid时才返回的参数。
        """
        pre_script: NotRequired[pulumi.Input[builtins.str]]
        """
        部署节点前执行脚本。
        """
        project_name: NotRequired[pulumi.Input[builtins.str]]
        """
        ECS所属项目，一个ECS只能归属于一个项目。
        """
        public_access_config: NotRequired[pulumi.Input['NodePoolNodeConfigPublicAccessConfigArgsDict']]
        """
        节点自动开启公网访问的配置信息
        """
        public_access_enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        节点是否自动开启公网访问。取值：  - false：关闭  - true：开启
        """
        security: NotRequired[pulumi.Input['NodePoolNodeConfigSecurityArgsDict']]
        """
        节点安全配置。
        """
        spot_strategy: NotRequired[pulumi.Input[builtins.str]]
        """
        按量计费的抢占式策略，当InstanceChargeType=PostPaid时NoSpot：正常按量计费实例。SpotAsPriceGo：系统自动出价，跟随当前市场实际价格。
        """
        subnet_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点网络所属的子网 ID 列表。
        """
        system_volume: NotRequired[pulumi.Input['NodePoolNodeConfigSystemVolumeArgsDict']]
        """
        节点的系统盘配置。
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigTagArgsDict']]]]
elif False:
    NodePoolNodeConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigArgs:
    def __init__(__self__, *,
                 additional_container_storage_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 auto_renew: Optional[pulumi.Input[builtins.bool]] = None,
                 auto_renew_period: Optional[pulumi.Input[builtins.int]] = None,
                 data_volumes: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigDataVolumeArgs']]]] = None,
                 deployment_set_group_number: Optional[pulumi.Input[builtins.int]] = None,
                 deployment_set_id: Optional[pulumi.Input[builtins.str]] = None,
                 hostname: Optional[pulumi.Input[builtins.str]] = None,
                 hpc_cluster_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 image_id: Optional[pulumi.Input[builtins.str]] = None,
                 initialize_script: Optional[pulumi.Input[builtins.str]] = None,
                 instance_charge_type: Optional[pulumi.Input[builtins.str]] = None,
                 instance_name: Optional[pulumi.Input[builtins.str]] = None,
                 instance_type_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 instances_distribution: Optional[pulumi.Input['NodePoolNodeConfigInstancesDistributionArgs']] = None,
                 name_prefix: Optional[pulumi.Input[builtins.str]] = None,
                 network_traffic_mode: Optional[pulumi.Input[builtins.str]] = None,
                 period: Optional[pulumi.Input[builtins.int]] = None,
                 pre_script: Optional[pulumi.Input[builtins.str]] = None,
                 project_name: Optional[pulumi.Input[builtins.str]] = None,
                 public_access_config: Optional[pulumi.Input['NodePoolNodeConfigPublicAccessConfigArgs']] = None,
                 public_access_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 security: Optional[pulumi.Input['NodePoolNodeConfigSecurityArgs']] = None,
                 spot_strategy: Optional[pulumi.Input[builtins.str]] = None,
                 subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 system_volume: Optional[pulumi.Input['NodePoolNodeConfigSystemVolumeArgs']] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigTagArgs']]]] = None):
        """
        :param pulumi.Input[builtins.bool] additional_container_storage_enabled: 节点的第一块数据盘是否已配置并格式化挂载作为容器镜像和日志的存储目录，参数值说明：false：未配置并格式化。true：已配置并格式化。
        :param pulumi.Input[builtins.bool] auto_renew: 云服务器实例到期是否自动续费，参数值说明：true：自动续费false：不自动续费仅当InstanceChargeType=PrePaid时才返回的参数。
        :param pulumi.Input[builtins.int] auto_renew_period: 云服务器实例每次自动续费时长，单位为月。仅当AutoRenew=true时才返回的参数。
        :param pulumi.Input[builtins.int] deployment_set_group_number: 实例在部署集中的分组号，0表示未设置
        :param pulumi.Input[builtins.str] deployment_set_id: 实例需要加入的部署集ID
        :param pulumi.Input[builtins.str] hostname: 节点对应的主机名称。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] hpc_cluster_ids: 高性能计算集群 ID。当节点池配置为高性能计算 GPU 型规格节点时，返回高性能计算集群 ID。
        :param pulumi.Input[builtins.str] image_id: 节点对应云服务器所使用的镜像 ID。
        :param pulumi.Input[builtins.str] initialize_script: 创建并初始化节点后执行的自定义脚本。Base64 编码后的 Shell 格式脚本。
        :param pulumi.Input[builtins.str] instance_charge_type: 云服务器实例计费类型，参数值说明：PostPaid：按量计费PrePaid：包年包月
        :param pulumi.Input[builtins.str] instance_name: 节点（实例）名称。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] instance_type_ids: 节点对应的云服务器实例规格 ID 列表。
        :param pulumi.Input['NodePoolNodeConfigInstancesDistributionArgs'] instances_distribution: 设置抢占式实例和按量实例的混合策略。当SpotStrategy为SpotAsPriceGo时，该策略生效。。
        :param pulumi.Input[builtins.str] name_prefix: 节点名称前缀，为空字符串或 nil 时表示未开启节点名称前缀策略。
        :param pulumi.Input[builtins.str] network_traffic_mode: 节点间的网络通讯模式。
        :param pulumi.Input[builtins.int] period: 云服务器实例购买时长，单位为月。仅当InstanceChargeType=PrePaid时才返回的参数。
        :param pulumi.Input[builtins.str] pre_script: 部署节点前执行脚本。
        :param pulumi.Input[builtins.str] project_name: ECS所属项目，一个ECS只能归属于一个项目。
        :param pulumi.Input['NodePoolNodeConfigPublicAccessConfigArgs'] public_access_config: 节点自动开启公网访问的配置信息
        :param pulumi.Input[builtins.bool] public_access_enabled: 节点是否自动开启公网访问。取值：  - false：关闭  - true：开启
        :param pulumi.Input['NodePoolNodeConfigSecurityArgs'] security: 节点安全配置。
        :param pulumi.Input[builtins.str] spot_strategy: 按量计费的抢占式策略，当InstanceChargeType=PostPaid时NoSpot：正常按量计费实例。SpotAsPriceGo：系统自动出价，跟随当前市场实际价格。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] subnet_ids: 节点网络所属的子网 ID 列表。
        :param pulumi.Input['NodePoolNodeConfigSystemVolumeArgs'] system_volume: 节点的系统盘配置。
        """
        if additional_container_storage_enabled is not None:
            pulumi.set(__self__, "additional_container_storage_enabled", additional_container_storage_enabled)
        if auto_renew is not None:
            pulumi.set(__self__, "auto_renew", auto_renew)
        if auto_renew_period is not None:
            pulumi.set(__self__, "auto_renew_period", auto_renew_period)
        if data_volumes is not None:
            pulumi.set(__self__, "data_volumes", data_volumes)
        if deployment_set_group_number is not None:
            pulumi.set(__self__, "deployment_set_group_number", deployment_set_group_number)
        if deployment_set_id is not None:
            pulumi.set(__self__, "deployment_set_id", deployment_set_id)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if hpc_cluster_ids is not None:
            pulumi.set(__self__, "hpc_cluster_ids", hpc_cluster_ids)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if initialize_script is not None:
            pulumi.set(__self__, "initialize_script", initialize_script)
        if instance_charge_type is not None:
            pulumi.set(__self__, "instance_charge_type", instance_charge_type)
        if instance_name is not None:
            pulumi.set(__self__, "instance_name", instance_name)
        if instance_type_ids is not None:
            pulumi.set(__self__, "instance_type_ids", instance_type_ids)
        if instances_distribution is not None:
            pulumi.set(__self__, "instances_distribution", instances_distribution)
        if name_prefix is not None:
            pulumi.set(__self__, "name_prefix", name_prefix)
        if network_traffic_mode is not None:
            pulumi.set(__self__, "network_traffic_mode", network_traffic_mode)
        if period is not None:
            pulumi.set(__self__, "period", period)
        if pre_script is not None:
            pulumi.set(__self__, "pre_script", pre_script)
        if project_name is not None:
            pulumi.set(__self__, "project_name", project_name)
        if public_access_config is not None:
            pulumi.set(__self__, "public_access_config", public_access_config)
        if public_access_enabled is not None:
            pulumi.set(__self__, "public_access_enabled", public_access_enabled)
        if security is not None:
            pulumi.set(__self__, "security", security)
        if spot_strategy is not None:
            pulumi.set(__self__, "spot_strategy", spot_strategy)
        if subnet_ids is not None:
            pulumi.set(__self__, "subnet_ids", subnet_ids)
        if system_volume is not None:
            pulumi.set(__self__, "system_volume", system_volume)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter(name="additionalContainerStorageEnabled")
    def additional_container_storage_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        节点的第一块数据盘是否已配置并格式化挂载作为容器镜像和日志的存储目录，参数值说明：false：未配置并格式化。true：已配置并格式化。
        """
        return pulumi.get(self, "additional_container_storage_enabled")

    @additional_container_storage_enabled.setter
    def additional_container_storage_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "additional_container_storage_enabled", value)

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        云服务器实例到期是否自动续费，参数值说明：true：自动续费false：不自动续费仅当InstanceChargeType=PrePaid时才返回的参数。
        """
        return pulumi.get(self, "auto_renew")

    @auto_renew.setter
    def auto_renew(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "auto_renew", value)

    @property
    @pulumi.getter(name="autoRenewPeriod")
    def auto_renew_period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        云服务器实例每次自动续费时长，单位为月。仅当AutoRenew=true时才返回的参数。
        """
        return pulumi.get(self, "auto_renew_period")

    @auto_renew_period.setter
    def auto_renew_period(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "auto_renew_period", value)

    @property
    @pulumi.getter(name="dataVolumes")
    def data_volumes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigDataVolumeArgs']]]]:
        return pulumi.get(self, "data_volumes")

    @data_volumes.setter
    def data_volumes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigDataVolumeArgs']]]]):
        pulumi.set(self, "data_volumes", value)

    @property
    @pulumi.getter(name="deploymentSetGroupNumber")
    def deployment_set_group_number(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        实例在部署集中的分组号，0表示未设置
        """
        return pulumi.get(self, "deployment_set_group_number")

    @deployment_set_group_number.setter
    def deployment_set_group_number(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "deployment_set_group_number", value)

    @property
    @pulumi.getter(name="deploymentSetId")
    def deployment_set_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例需要加入的部署集ID
        """
        return pulumi.get(self, "deployment_set_id")

    @deployment_set_id.setter
    def deployment_set_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "deployment_set_id", value)

    @property
    @pulumi.getter
    def hostname(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点对应的主机名称。
        """
        return pulumi.get(self, "hostname")

    @hostname.setter
    def hostname(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "hostname", value)

    @property
    @pulumi.getter(name="hpcClusterIds")
    def hpc_cluster_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        高性能计算集群 ID。当节点池配置为高性能计算 GPU 型规格节点时，返回高性能计算集群 ID。
        """
        return pulumi.get(self, "hpc_cluster_ids")

    @hpc_cluster_ids.setter
    def hpc_cluster_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "hpc_cluster_ids", value)

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点对应云服务器所使用的镜像 ID。
        """
        return pulumi.get(self, "image_id")

    @image_id.setter
    def image_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "image_id", value)

    @property
    @pulumi.getter(name="initializeScript")
    def initialize_script(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        创建并初始化节点后执行的自定义脚本。Base64 编码后的 Shell 格式脚本。
        """
        return pulumi.get(self, "initialize_script")

    @initialize_script.setter
    def initialize_script(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "initialize_script", value)

    @property
    @pulumi.getter(name="instanceChargeType")
    def instance_charge_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        云服务器实例计费类型，参数值说明：PostPaid：按量计费PrePaid：包年包月
        """
        return pulumi.get(self, "instance_charge_type")

    @instance_charge_type.setter
    def instance_charge_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "instance_charge_type", value)

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点（实例）名称。
        """
        return pulumi.get(self, "instance_name")

    @instance_name.setter
    def instance_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "instance_name", value)

    @property
    @pulumi.getter(name="instanceTypeIds")
    def instance_type_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点对应的云服务器实例规格 ID 列表。
        """
        return pulumi.get(self, "instance_type_ids")

    @instance_type_ids.setter
    def instance_type_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "instance_type_ids", value)

    @property
    @pulumi.getter(name="instancesDistribution")
    def instances_distribution(self) -> Optional[pulumi.Input['NodePoolNodeConfigInstancesDistributionArgs']]:
        """
        设置抢占式实例和按量实例的混合策略。当SpotStrategy为SpotAsPriceGo时，该策略生效。。
        """
        return pulumi.get(self, "instances_distribution")

    @instances_distribution.setter
    def instances_distribution(self, value: Optional[pulumi.Input['NodePoolNodeConfigInstancesDistributionArgs']]):
        pulumi.set(self, "instances_distribution", value)

    @property
    @pulumi.getter(name="namePrefix")
    def name_prefix(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点名称前缀，为空字符串或 nil 时表示未开启节点名称前缀策略。
        """
        return pulumi.get(self, "name_prefix")

    @name_prefix.setter
    def name_prefix(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "name_prefix", value)

    @property
    @pulumi.getter(name="networkTrafficMode")
    def network_traffic_mode(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点间的网络通讯模式。
        """
        return pulumi.get(self, "network_traffic_mode")

    @network_traffic_mode.setter
    def network_traffic_mode(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "network_traffic_mode", value)

    @property
    @pulumi.getter
    def period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        云服务器实例购买时长，单位为月。仅当InstanceChargeType=PrePaid时才返回的参数。
        """
        return pulumi.get(self, "period")

    @period.setter
    def period(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "period", value)

    @property
    @pulumi.getter(name="preScript")
    def pre_script(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        部署节点前执行脚本。
        """
        return pulumi.get(self, "pre_script")

    @pre_script.setter
    def pre_script(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "pre_script", value)

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        ECS所属项目，一个ECS只能归属于一个项目。
        """
        return pulumi.get(self, "project_name")

    @project_name.setter
    def project_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "project_name", value)

    @property
    @pulumi.getter(name="publicAccessConfig")
    def public_access_config(self) -> Optional[pulumi.Input['NodePoolNodeConfigPublicAccessConfigArgs']]:
        """
        节点自动开启公网访问的配置信息
        """
        return pulumi.get(self, "public_access_config")

    @public_access_config.setter
    def public_access_config(self, value: Optional[pulumi.Input['NodePoolNodeConfigPublicAccessConfigArgs']]):
        pulumi.set(self, "public_access_config", value)

    @property
    @pulumi.getter(name="publicAccessEnabled")
    def public_access_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        节点是否自动开启公网访问。取值：  - false：关闭  - true：开启
        """
        return pulumi.get(self, "public_access_enabled")

    @public_access_enabled.setter
    def public_access_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "public_access_enabled", value)

    @property
    @pulumi.getter
    def security(self) -> Optional[pulumi.Input['NodePoolNodeConfigSecurityArgs']]:
        """
        节点安全配置。
        """
        return pulumi.get(self, "security")

    @security.setter
    def security(self, value: Optional[pulumi.Input['NodePoolNodeConfigSecurityArgs']]):
        pulumi.set(self, "security", value)

    @property
    @pulumi.getter(name="spotStrategy")
    def spot_strategy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        按量计费的抢占式策略，当InstanceChargeType=PostPaid时NoSpot：正常按量计费实例。SpotAsPriceGo：系统自动出价，跟随当前市场实际价格。
        """
        return pulumi.get(self, "spot_strategy")

    @spot_strategy.setter
    def spot_strategy(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "spot_strategy", value)

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点网络所属的子网 ID 列表。
        """
        return pulumi.get(self, "subnet_ids")

    @subnet_ids.setter
    def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "subnet_ids", value)

    @property
    @pulumi.getter(name="systemVolume")
    def system_volume(self) -> Optional[pulumi.Input['NodePoolNodeConfigSystemVolumeArgs']]:
        """
        节点的系统盘配置。
        """
        return pulumi.get(self, "system_volume")

    @system_volume.setter
    def system_volume(self, value: Optional[pulumi.Input['NodePoolNodeConfigSystemVolumeArgs']]):
        pulumi.set(self, "system_volume", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigTagArgs']]]]:
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolNodeConfigTagArgs']]]]):
        pulumi.set(self, "tags", value)


if not MYPY:
    class NodePoolNodeConfigDataVolumeArgsDict(TypedDict):
        file_system: NotRequired[pulumi.Input[builtins.str]]
        """
        文件系统，取值：  - Ext4 (默认值)  - Xfs
        """
        mount_point: NotRequired[pulumi.Input[builtins.str]]
        """
        磁盘格式化后的目标挂载目录。
        """
        placement_group_id: NotRequired[pulumi.Input[builtins.str]]
        """
        放置组Id
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        磁盘容量，单位 GiB。
        """
        snapshot_id: NotRequired[pulumi.Input[builtins.str]]
        """
        使用快照创建数据盘。您可以调用DescribeSnapshots接口查询快照ID。说明  - 仅极速型SSD和高效性云盘支持通过快照创建云盘  - 仅状态为“可用”(available)的快照支持创建新云盘，“创建中”、“回滚中”、“删除中”及“错误”状态下的快照不支持创建新云盘。
        """
        subgroup_number: NotRequired[pulumi.Input[builtins.int]]
        """
        放置子组
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        磁盘类型：ESSD*PL0：性能级别为 PL0 的极速型 SSD 云盘。ESSD*FlexPL：性能级别为 PL1 的极速型 SSD 云盘。
        """
elif False:
    NodePoolNodeConfigDataVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigDataVolumeArgs:
    def __init__(__self__, *,
                 file_system: Optional[pulumi.Input[builtins.str]] = None,
                 mount_point: Optional[pulumi.Input[builtins.str]] = None,
                 placement_group_id: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 snapshot_id: Optional[pulumi.Input[builtins.str]] = None,
                 subgroup_number: Optional[pulumi.Input[builtins.int]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] file_system: 文件系统，取值：  - Ext4 (默认值)  - Xfs
        :param pulumi.Input[builtins.str] mount_point: 磁盘格式化后的目标挂载目录。
        :param pulumi.Input[builtins.str] placement_group_id: 放置组Id
        :param pulumi.Input[builtins.int] size: 磁盘容量，单位 GiB。
        :param pulumi.Input[builtins.str] snapshot_id: 使用快照创建数据盘。您可以调用DescribeSnapshots接口查询快照ID。说明  - 仅极速型SSD和高效性云盘支持通过快照创建云盘  - 仅状态为“可用”(available)的快照支持创建新云盘，“创建中”、“回滚中”、“删除中”及“错误”状态下的快照不支持创建新云盘。
        :param pulumi.Input[builtins.int] subgroup_number: 放置子组
        :param pulumi.Input[builtins.str] type: 磁盘类型：ESSD*PL0：性能级别为 PL0 的极速型 SSD 云盘。ESSD*FlexPL：性能级别为 PL1 的极速型 SSD 云盘。
        """
        if file_system is not None:
            pulumi.set(__self__, "file_system", file_system)
        if mount_point is not None:
            pulumi.set(__self__, "mount_point", mount_point)
        if placement_group_id is not None:
            pulumi.set(__self__, "placement_group_id", placement_group_id)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if snapshot_id is not None:
            pulumi.set(__self__, "snapshot_id", snapshot_id)
        if subgroup_number is not None:
            pulumi.set(__self__, "subgroup_number", subgroup_number)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="fileSystem")
    def file_system(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        文件系统，取值：  - Ext4 (默认值)  - Xfs
        """
        return pulumi.get(self, "file_system")

    @file_system.setter
    def file_system(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "file_system", value)

    @property
    @pulumi.getter(name="mountPoint")
    def mount_point(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        磁盘格式化后的目标挂载目录。
        """
        return pulumi.get(self, "mount_point")

    @mount_point.setter
    def mount_point(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "mount_point", value)

    @property
    @pulumi.getter(name="placementGroupId")
    def placement_group_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        放置组Id
        """
        return pulumi.get(self, "placement_group_id")

    @placement_group_id.setter
    def placement_group_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "placement_group_id", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        磁盘容量，单位 GiB。
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter(name="snapshotId")
    def snapshot_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        使用快照创建数据盘。您可以调用DescribeSnapshots接口查询快照ID。说明  - 仅极速型SSD和高效性云盘支持通过快照创建云盘  - 仅状态为“可用”(available)的快照支持创建新云盘，“创建中”、“回滚中”、“删除中”及“错误”状态下的快照不支持创建新云盘。
        """
        return pulumi.get(self, "snapshot_id")

    @snapshot_id.setter
    def snapshot_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "snapshot_id", value)

    @property
    @pulumi.getter(name="subgroupNumber")
    def subgroup_number(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        放置子组
        """
        return pulumi.get(self, "subgroup_number")

    @subgroup_number.setter
    def subgroup_number(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "subgroup_number", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        磁盘类型：ESSD*PL0：性能级别为 PL0 的极速型 SSD 云盘。ESSD*FlexPL：性能级别为 PL1 的极速型 SSD 云盘。
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class NodePoolNodeConfigInstancesDistributionArgsDict(TypedDict):
        capacity_rebalance: NotRequired[pulumi.Input[builtins.bool]]
        """
        容量重新平衡。取值范围：  - true：开启该功能，当抢占式实例即将被回收前，主动创建新的抢占式实例进行补偿。  - false（默认值）：不开启该功能，则等待抢占式实例被回收后才会去扩容补齐实例数
        """
        compensate_with_on_demand: NotRequired[pulumi.Input[builtins.bool]]
        """
        按量实例替补功能。取值范围：  - true：开启该功能，当所有抢占式实例因库存不足等原因全部购买失败后，尝试购买按量实例  - false（默认值）：不开启该功能，在需要扩容抢占式实例时仅尝试所配置的抢占式实例
        """
        on_demand_base_capacity: NotRequired[pulumi.Input[builtins.int]]
        """
        基础容量的大小，基础容量部分固定为按量计费实例。取值范围：[0,500]，默认值为0。
        """
        on_demand_percentage_above_base_capacity: NotRequired[pulumi.Input[builtins.int]]
        """
        超出基础容量部分，按量计费实例所占的比例。取值范围[0, 100]，0代表超出基础容量的部分仅生产抢占式实例，100代表仅生产按量实例，默认值为0。
        """
elif False:
    NodePoolNodeConfigInstancesDistributionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigInstancesDistributionArgs:
    def __init__(__self__, *,
                 capacity_rebalance: Optional[pulumi.Input[builtins.bool]] = None,
                 compensate_with_on_demand: Optional[pulumi.Input[builtins.bool]] = None,
                 on_demand_base_capacity: Optional[pulumi.Input[builtins.int]] = None,
                 on_demand_percentage_above_base_capacity: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.bool] capacity_rebalance: 容量重新平衡。取值范围：  - true：开启该功能，当抢占式实例即将被回收前，主动创建新的抢占式实例进行补偿。  - false（默认值）：不开启该功能，则等待抢占式实例被回收后才会去扩容补齐实例数
        :param pulumi.Input[builtins.bool] compensate_with_on_demand: 按量实例替补功能。取值范围：  - true：开启该功能，当所有抢占式实例因库存不足等原因全部购买失败后，尝试购买按量实例  - false（默认值）：不开启该功能，在需要扩容抢占式实例时仅尝试所配置的抢占式实例
        :param pulumi.Input[builtins.int] on_demand_base_capacity: 基础容量的大小，基础容量部分固定为按量计费实例。取值范围：[0,500]，默认值为0。
        :param pulumi.Input[builtins.int] on_demand_percentage_above_base_capacity: 超出基础容量部分，按量计费实例所占的比例。取值范围[0, 100]，0代表超出基础容量的部分仅生产抢占式实例，100代表仅生产按量实例，默认值为0。
        """
        if capacity_rebalance is not None:
            pulumi.set(__self__, "capacity_rebalance", capacity_rebalance)
        if compensate_with_on_demand is not None:
            pulumi.set(__self__, "compensate_with_on_demand", compensate_with_on_demand)
        if on_demand_base_capacity is not None:
            pulumi.set(__self__, "on_demand_base_capacity", on_demand_base_capacity)
        if on_demand_percentage_above_base_capacity is not None:
            pulumi.set(__self__, "on_demand_percentage_above_base_capacity", on_demand_percentage_above_base_capacity)

    @property
    @pulumi.getter(name="capacityRebalance")
    def capacity_rebalance(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        容量重新平衡。取值范围：  - true：开启该功能，当抢占式实例即将被回收前，主动创建新的抢占式实例进行补偿。  - false（默认值）：不开启该功能，则等待抢占式实例被回收后才会去扩容补齐实例数
        """
        return pulumi.get(self, "capacity_rebalance")

    @capacity_rebalance.setter
    def capacity_rebalance(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "capacity_rebalance", value)

    @property
    @pulumi.getter(name="compensateWithOnDemand")
    def compensate_with_on_demand(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        按量实例替补功能。取值范围：  - true：开启该功能，当所有抢占式实例因库存不足等原因全部购买失败后，尝试购买按量实例  - false（默认值）：不开启该功能，在需要扩容抢占式实例时仅尝试所配置的抢占式实例
        """
        return pulumi.get(self, "compensate_with_on_demand")

    @compensate_with_on_demand.setter
    def compensate_with_on_demand(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "compensate_with_on_demand", value)

    @property
    @pulumi.getter(name="onDemandBaseCapacity")
    def on_demand_base_capacity(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        基础容量的大小，基础容量部分固定为按量计费实例。取值范围：[0,500]，默认值为0。
        """
        return pulumi.get(self, "on_demand_base_capacity")

    @on_demand_base_capacity.setter
    def on_demand_base_capacity(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "on_demand_base_capacity", value)

    @property
    @pulumi.getter(name="onDemandPercentageAboveBaseCapacity")
    def on_demand_percentage_above_base_capacity(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        超出基础容量部分，按量计费实例所占的比例。取值范围[0, 100]，0代表超出基础容量的部分仅生产抢占式实例，100代表仅生产按量实例，默认值为0。
        """
        return pulumi.get(self, "on_demand_percentage_above_base_capacity")

    @on_demand_percentage_above_base_capacity.setter
    def on_demand_percentage_above_base_capacity(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "on_demand_percentage_above_base_capacity", value)


if not MYPY:
    class NodePoolNodeConfigPublicAccessConfigArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        公网 IP 的带宽峰值，单位：Mbps。
        """
        billing_type: NotRequired[pulumi.Input[builtins.int]]
        """
        公网 IP 的计费类型：2：按量计费-按带宽上限。3：按量计费-按实际流量。
        """
        isp: NotRequired[pulumi.Input[builtins.str]]
        """
        公网 IP 的线路类型，参数值说明： BGP：BGP（多线）。
        """
elif False:
    NodePoolNodeConfigPublicAccessConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigPublicAccessConfigArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 billing_type: Optional[pulumi.Input[builtins.int]] = None,
                 isp: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: 公网 IP 的带宽峰值，单位：Mbps。
        :param pulumi.Input[builtins.int] billing_type: 公网 IP 的计费类型：2：按量计费-按带宽上限。3：按量计费-按实际流量。
        :param pulumi.Input[builtins.str] isp: 公网 IP 的线路类型，参数值说明： BGP：BGP（多线）。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if billing_type is not None:
            pulumi.set(__self__, "billing_type", billing_type)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网 IP 的带宽峰值，单位：Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @bandwidth.setter
    def bandwidth(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "bandwidth", value)

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网 IP 的计费类型：2：按量计费-按带宽上限。3：按量计费-按实际流量。
        """
        return pulumi.get(self, "billing_type")

    @billing_type.setter
    def billing_type(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "billing_type", value)

    @property
    @pulumi.getter
    def isp(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        公网 IP 的线路类型，参数值说明： BGP：BGP（多线）。
        """
        return pulumi.get(self, "isp")

    @isp.setter
    def isp(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "isp", value)


if not MYPY:
    class NodePoolNodeConfigSecurityArgsDict(TypedDict):
        login: NotRequired[pulumi.Input['NodePoolNodeConfigSecurityLoginArgsDict']]
        """
        节点的访问方式配置。
        """
        security_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点网络所在的安全组 ID 列表。
        """
        security_strategies: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点的安全策略，参数值说明：Hids：主机安全加固。
        """
        security_strategy_enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        节点是否启用了安全加固配置，参数值说明：true：已开启。false：未开启。
        """
elif False:
    NodePoolNodeConfigSecurityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigSecurityArgs:
    def __init__(__self__, *,
                 login: Optional[pulumi.Input['NodePoolNodeConfigSecurityLoginArgs']] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 security_strategies: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 security_strategy_enabled: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input['NodePoolNodeConfigSecurityLoginArgs'] login: 节点的访问方式配置。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: 节点网络所在的安全组 ID 列表。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_strategies: 节点的安全策略，参数值说明：Hids：主机安全加固。
        :param pulumi.Input[builtins.bool] security_strategy_enabled: 节点是否启用了安全加固配置，参数值说明：true：已开启。false：未开启。
        """
        if login is not None:
            pulumi.set(__self__, "login", login)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if security_strategies is not None:
            pulumi.set(__self__, "security_strategies", security_strategies)
        if security_strategy_enabled is not None:
            pulumi.set(__self__, "security_strategy_enabled", security_strategy_enabled)

    @property
    @pulumi.getter
    def login(self) -> Optional[pulumi.Input['NodePoolNodeConfigSecurityLoginArgs']]:
        """
        节点的访问方式配置。
        """
        return pulumi.get(self, "login")

    @login.setter
    def login(self, value: Optional[pulumi.Input['NodePoolNodeConfigSecurityLoginArgs']]):
        pulumi.set(self, "login", value)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点网络所在的安全组 ID 列表。
        """
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter(name="securityStrategies")
    def security_strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点的安全策略，参数值说明：Hids：主机安全加固。
        """
        return pulumi.get(self, "security_strategies")

    @security_strategies.setter
    def security_strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "security_strategies", value)

    @property
    @pulumi.getter(name="securityStrategyEnabled")
    def security_strategy_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        节点是否启用了安全加固配置，参数值说明：true：已开启。false：未开启。
        """
        return pulumi.get(self, "security_strategy_enabled")

    @security_strategy_enabled.setter
    def security_strategy_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "security_strategy_enabled", value)


if not MYPY:
    class NodePoolNodeConfigSecurityLoginArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[builtins.str]]
        """
        Root 用户登录密码，使用 Base64 编码格式。请遵循云服务器对于实例密码的要求规范：长度为 8～30 个字符，不能以/和$6$开头，支持以下几项字符，且至少包含三项，小写字母a~z，大写字母A~Z，数字0~9，特殊字符( ) ` ~ ! @ # $ % ^ & * _   - + = | { } [ ] : ; ' < > , . ? /
        """
        ssh_key_pair_name: NotRequired[pulumi.Input[builtins.str]]
        """
        SSH 密钥对名称。请确保该密钥对已在云服务器中创建或托管。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        节点的访问登录方式，参数值说明：Password：密码登录。SshKeyPair：SSH 密钥对登录。
        """
elif False:
    NodePoolNodeConfigSecurityLoginArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigSecurityLoginArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[builtins.str]] = None,
                 ssh_key_pair_name: Optional[pulumi.Input[builtins.str]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] password: Root 用户登录密码，使用 Base64 编码格式。请遵循云服务器对于实例密码的要求规范：长度为 8～30 个字符，不能以/和$6$开头，支持以下几项字符，且至少包含三项，小写字母a~z，大写字母A~Z，数字0~9，特殊字符( ) ` ~ ! @ # $ % ^ & * _   - + = | { } [ ] : ; ' < > , . ? /
        :param pulumi.Input[builtins.str] ssh_key_pair_name: SSH 密钥对名称。请确保该密钥对已在云服务器中创建或托管。
        :param pulumi.Input[builtins.str] type: 节点的访问登录方式，参数值说明：Password：密码登录。SshKeyPair：SSH 密钥对登录。
        """
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssh_key_pair_name is not None:
            pulumi.set(__self__, "ssh_key_pair_name", ssh_key_pair_name)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Root 用户登录密码，使用 Base64 编码格式。请遵循云服务器对于实例密码的要求规范：长度为 8～30 个字符，不能以/和$6$开头，支持以下几项字符，且至少包含三项，小写字母a~z，大写字母A~Z，数字0~9，特殊字符( ) ` ~ ! @ # $ % ^ & * _   - + = | { } [ ] : ; ' < > , . ? /
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "password", value)

    @property
    @pulumi.getter(name="sshKeyPairName")
    def ssh_key_pair_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        SSH 密钥对名称。请确保该密钥对已在云服务器中创建或托管。
        """
        return pulumi.get(self, "ssh_key_pair_name")

    @ssh_key_pair_name.setter
    def ssh_key_pair_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "ssh_key_pair_name", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点的访问登录方式，参数值说明：Password：密码登录。SshKeyPair：SSH 密钥对登录。
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class NodePoolNodeConfigSystemVolumeArgsDict(TypedDict):
        placement_group_id: NotRequired[pulumi.Input[builtins.str]]
        """
        放置组Id
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        云盘容量，单位 GiB，取值说明：默认值：40GiB。极速型 SSD（ESSD*PL0，ESSD*FlexPL）：40~2048GiB。
        """
        subgroup_number: NotRequired[pulumi.Input[builtins.int]]
        """
        放置子组
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        云盘类型：ESSD*PL0：（默认值）性能级别为 PL0 的极速型 SSD 云盘。ESSD*FlexPL：性能级别为 PL1 的极速型 SSD 云盘。
        """
elif False:
    NodePoolNodeConfigSystemVolumeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigSystemVolumeArgs:
    def __init__(__self__, *,
                 placement_group_id: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 subgroup_number: Optional[pulumi.Input[builtins.int]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] placement_group_id: 放置组Id
        :param pulumi.Input[builtins.int] size: 云盘容量，单位 GiB，取值说明：默认值：40GiB。极速型 SSD（ESSD*PL0，ESSD*FlexPL）：40~2048GiB。
        :param pulumi.Input[builtins.int] subgroup_number: 放置子组
        :param pulumi.Input[builtins.str] type: 云盘类型：ESSD*PL0：（默认值）性能级别为 PL0 的极速型 SSD 云盘。ESSD*FlexPL：性能级别为 PL1 的极速型 SSD 云盘。
        """
        if placement_group_id is not None:
            pulumi.set(__self__, "placement_group_id", placement_group_id)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if subgroup_number is not None:
            pulumi.set(__self__, "subgroup_number", subgroup_number)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="placementGroupId")
    def placement_group_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        放置组Id
        """
        return pulumi.get(self, "placement_group_id")

    @placement_group_id.setter
    def placement_group_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "placement_group_id", value)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        云盘容量，单位 GiB，取值说明：默认值：40GiB。极速型 SSD（ESSD*PL0，ESSD*FlexPL）：40~2048GiB。
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "size", value)

    @property
    @pulumi.getter(name="subgroupNumber")
    def subgroup_number(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        放置子组
        """
        return pulumi.get(self, "subgroup_number")

    @subgroup_number.setter
    def subgroup_number(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "subgroup_number", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        云盘类型：ESSD*PL0：（默认值）性能级别为 PL0 的极速型 SSD 云盘。ESSD*FlexPL：性能级别为 PL1 的极速型 SSD 云盘。
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class NodePoolNodeConfigTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签值。
        """
elif False:
    NodePoolNodeConfigTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeConfigTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签键。
        :param pulumi.Input[builtins.str] value: 标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签值。
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class NodePoolNodeStatisticsArgsDict(TypedDict):
        creating_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Creating的节点总数量。
        """
        deleting_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Deleting的节点总数量。
        """
        failed_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Failed的节点总数量。
        """
        running_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Running的节点总数量。
        """
        total_count: NotRequired[pulumi.Input[builtins.int]]
        """
        节点池中的节点总数量。
        """
        updating_count: NotRequired[pulumi.Input[builtins.int]]
        """
        Phase=Updating的节点总数量。
        """
elif False:
    NodePoolNodeStatisticsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolNodeStatisticsArgs:
    def __init__(__self__, *,
                 creating_count: Optional[pulumi.Input[builtins.int]] = None,
                 deleting_count: Optional[pulumi.Input[builtins.int]] = None,
                 failed_count: Optional[pulumi.Input[builtins.int]] = None,
                 running_count: Optional[pulumi.Input[builtins.int]] = None,
                 total_count: Optional[pulumi.Input[builtins.int]] = None,
                 updating_count: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] creating_count: Phase=Creating的节点总数量。
        :param pulumi.Input[builtins.int] deleting_count: Phase=Deleting的节点总数量。
        :param pulumi.Input[builtins.int] failed_count: Phase=Failed的节点总数量。
        :param pulumi.Input[builtins.int] running_count: Phase=Running的节点总数量。
        :param pulumi.Input[builtins.int] total_count: 节点池中的节点总数量。
        :param pulumi.Input[builtins.int] updating_count: Phase=Updating的节点总数量。
        """
        if creating_count is not None:
            pulumi.set(__self__, "creating_count", creating_count)
        if deleting_count is not None:
            pulumi.set(__self__, "deleting_count", deleting_count)
        if failed_count is not None:
            pulumi.set(__self__, "failed_count", failed_count)
        if running_count is not None:
            pulumi.set(__self__, "running_count", running_count)
        if total_count is not None:
            pulumi.set(__self__, "total_count", total_count)
        if updating_count is not None:
            pulumi.set(__self__, "updating_count", updating_count)

    @property
    @pulumi.getter(name="creatingCount")
    def creating_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Creating的节点总数量。
        """
        return pulumi.get(self, "creating_count")

    @creating_count.setter
    def creating_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "creating_count", value)

    @property
    @pulumi.getter(name="deletingCount")
    def deleting_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Deleting的节点总数量。
        """
        return pulumi.get(self, "deleting_count")

    @deleting_count.setter
    def deleting_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "deleting_count", value)

    @property
    @pulumi.getter(name="failedCount")
    def failed_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Failed的节点总数量。
        """
        return pulumi.get(self, "failed_count")

    @failed_count.setter
    def failed_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "failed_count", value)

    @property
    @pulumi.getter(name="runningCount")
    def running_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Running的节点总数量。
        """
        return pulumi.get(self, "running_count")

    @running_count.setter
    def running_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "running_count", value)

    @property
    @pulumi.getter(name="totalCount")
    def total_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点池中的节点总数量。
        """
        return pulumi.get(self, "total_count")

    @total_count.setter
    def total_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "total_count", value)

    @property
    @pulumi.getter(name="updatingCount")
    def updating_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Phase=Updating的节点总数量。
        """
        return pulumi.get(self, "updating_count")

    @updating_count.setter
    def updating_count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "updating_count", value)


if not MYPY:
    class NodePoolStatusArgsDict(TypedDict):
        conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodePoolStatusConditionArgsDict']]]]
        phase: NotRequired[pulumi.Input[builtins.str]]
        """
        节点池的状态，参数值有：Creating、Running、Updating、Deleting、Failed、Scaling。
        """
elif False:
    NodePoolStatusArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolStatusArgs:
    def __init__(__self__, *,
                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolStatusConditionArgs']]]] = None,
                 phase: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] phase: 节点池的状态，参数值有：Creating、Running、Updating、Deleting、Failed、Scaling。
        """
        if conditions is not None:
            pulumi.set(__self__, "conditions", conditions)
        if phase is not None:
            pulumi.set(__self__, "phase", phase)

    @property
    @pulumi.getter
    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolStatusConditionArgs']]]]:
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodePoolStatusConditionArgs']]]]):
        pulumi.set(self, "conditions", value)

    @property
    @pulumi.getter
    def phase(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点池的状态，参数值有：Creating、Running、Updating、Deleting、Failed、Scaling。
        """
        return pulumi.get(self, "phase")

    @phase.setter
    def phase(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "phase", value)


if not MYPY:
    class NodePoolStatusConditionArgsDict(TypedDict):
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        节点池当前主状态下的状态条件，即进入该主状态的原因，可以有多个原因，参数值有：ProgressingOk、ResourceCleanupFailed、Unknown、ClusterNotRunning。
        """
elif False:
    NodePoolStatusConditionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolStatusConditionArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] type: 节点池当前主状态下的状态条件，即进入该主状态的原因，可以有多个原因，参数值有：ProgressingOk、ResourceCleanupFailed、Unknown、ClusterNotRunning。
        """
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点池当前主状态下的状态条件，即进入该主状态的原因，可以有多个原因，参数值有：ProgressingOk、ResourceCleanupFailed、Unknown、ClusterNotRunning。
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class NodePoolTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签值。
        """
elif False:
    NodePoolTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodePoolTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签键。
        :param pulumi.Input[builtins.str] value: 标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签值。
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)


