# 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__ = [
    'ClusterApplicationArgs',
    'ClusterApplicationArgsDict',
    'ClusterApplicationExtraArgs',
    'ClusterApplicationExtraArgsDict',
    'ClusterApplicationExtraApplicationComponentLayoutArgs',
    'ClusterApplicationExtraApplicationComponentLayoutArgsDict',
    'ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgs',
    'ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgsDict',
    'ClusterApplicationExtraApplicationConfigArgs',
    'ClusterApplicationExtraApplicationConfigArgsDict',
    'ClusterApplicationExtraApplicationConfigEffectiveScopeArgs',
    'ClusterApplicationExtraApplicationConfigEffectiveScopeArgsDict',
    'ClusterBootstrapScriptArgs',
    'ClusterBootstrapScriptArgsDict',
    'ClusterBootstrapScriptEffectiveScopeArgs',
    'ClusterBootstrapScriptEffectiveScopeArgsDict',
    'ClusterChargePreConfigArgs',
    'ClusterChargePreConfigArgsDict',
    'ClusterNodeAttributeArgs',
    'ClusterNodeAttributeArgsDict',
    'ClusterNodeGroupAttributeArgs',
    'ClusterNodeGroupAttributeArgsDict',
    'ClusterNodeGroupAttributeDataDiskArgs',
    'ClusterNodeGroupAttributeDataDiskArgsDict',
    'ClusterNodeGroupAttributeSystemDiskArgs',
    'ClusterNodeGroupAttributeSystemDiskArgsDict',
    'ClusterStateChangeReasonArgs',
    'ClusterStateChangeReasonArgsDict',
    'ClusterTagArgs',
    'ClusterTagArgsDict',
    'NodeGroupApplicationLayoutArgs',
    'NodeGroupApplicationLayoutArgsDict',
    'NodeGroupChargePreConfigArgs',
    'NodeGroupChargePreConfigArgsDict',
    'NodeGroupDataDiskArgs',
    'NodeGroupDataDiskArgsDict',
    'NodeGroupNodeArgs',
    'NodeGroupNodeArgsDict',
    'NodeGroupSystemDiskArgs',
    'NodeGroupSystemDiskArgsDict',
]

MYPY = False

if not MYPY:
    class ClusterApplicationArgsDict(TypedDict):
        application_config_home: NotRequired[pulumi.Input[builtins.str]]
        """
        应用配置路径。
        """
        application_home: NotRequired[pulumi.Input[builtins.str]]
        """
        应用安装路径。
        """
        application_name: NotRequired[pulumi.Input[builtins.str]]
        """
        应用名称。
        """
        application_state: NotRequired[pulumi.Input[builtins.str]]
        """
        服务状态。NORMAL：正常；WARNING：告警；STOPPED：已停止；INIT：初始化中；INSTALLING：安装中；INSTALLED：已安装；STARTING：启动中；STARTED：已启动；STOPPING：停止中；UNINSTALLING：卸载中；UNINSTALLED：已卸载；EXCEPTION：异常。
        """
        application_version: NotRequired[pulumi.Input[builtins.str]]
        """
        应用版本。
        """
        group: NotRequired[pulumi.Input[builtins.str]]
        """
        应用用户组。
        """
        support_client: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否支持客户端。
        """
        user: NotRequired[pulumi.Input[builtins.str]]
        """
        应用用户。
        """
elif False:
    ClusterApplicationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterApplicationArgs:
    def __init__(__self__, *,
                 application_config_home: Optional[pulumi.Input[builtins.str]] = None,
                 application_home: Optional[pulumi.Input[builtins.str]] = None,
                 application_name: Optional[pulumi.Input[builtins.str]] = None,
                 application_state: Optional[pulumi.Input[builtins.str]] = None,
                 application_version: Optional[pulumi.Input[builtins.str]] = None,
                 group: Optional[pulumi.Input[builtins.str]] = None,
                 support_client: Optional[pulumi.Input[builtins.bool]] = None,
                 user: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] application_config_home: 应用配置路径。
        :param pulumi.Input[builtins.str] application_home: 应用安装路径。
        :param pulumi.Input[builtins.str] application_name: 应用名称。
        :param pulumi.Input[builtins.str] application_state: 服务状态。NORMAL：正常；WARNING：告警；STOPPED：已停止；INIT：初始化中；INSTALLING：安装中；INSTALLED：已安装；STARTING：启动中；STARTED：已启动；STOPPING：停止中；UNINSTALLING：卸载中；UNINSTALLED：已卸载；EXCEPTION：异常。
        :param pulumi.Input[builtins.str] application_version: 应用版本。
        :param pulumi.Input[builtins.str] group: 应用用户组。
        :param pulumi.Input[builtins.bool] support_client: 是否支持客户端。
        :param pulumi.Input[builtins.str] user: 应用用户。
        """
        if application_config_home is not None:
            pulumi.set(__self__, "application_config_home", application_config_home)
        if application_home is not None:
            pulumi.set(__self__, "application_home", application_home)
        if application_name is not None:
            pulumi.set(__self__, "application_name", application_name)
        if application_state is not None:
            pulumi.set(__self__, "application_state", application_state)
        if application_version is not None:
            pulumi.set(__self__, "application_version", application_version)
        if group is not None:
            pulumi.set(__self__, "group", group)
        if support_client is not None:
            pulumi.set(__self__, "support_client", support_client)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter(name="applicationConfigHome")
    def application_config_home(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用配置路径。
        """
        return pulumi.get(self, "application_config_home")

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

    @property
    @pulumi.getter(name="applicationHome")
    def application_home(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用安装路径。
        """
        return pulumi.get(self, "application_home")

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

    @property
    @pulumi.getter(name="applicationName")
    def application_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用名称。
        """
        return pulumi.get(self, "application_name")

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

    @property
    @pulumi.getter(name="applicationState")
    def application_state(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        服务状态。NORMAL：正常；WARNING：告警；STOPPED：已停止；INIT：初始化中；INSTALLING：安装中；INSTALLED：已安装；STARTING：启动中；STARTED：已启动；STOPPING：停止中；UNINSTALLING：卸载中；UNINSTALLED：已卸载；EXCEPTION：异常。
        """
        return pulumi.get(self, "application_state")

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

    @property
    @pulumi.getter(name="applicationVersion")
    def application_version(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用版本。
        """
        return pulumi.get(self, "application_version")

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

    @property
    @pulumi.getter
    def group(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用用户组。
        """
        return pulumi.get(self, "group")

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

    @property
    @pulumi.getter(name="supportClient")
    def support_client(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否支持客户端。
        """
        return pulumi.get(self, "support_client")

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

    @property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用用户。
        """
        return pulumi.get(self, "user")

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


if not MYPY:
    class ClusterApplicationExtraArgsDict(TypedDict):
        application_component_layouts: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterApplicationExtraApplicationComponentLayoutArgsDict']]]]
        application_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterApplicationExtraApplicationConfigArgsDict']]]]
        application_name: NotRequired[pulumi.Input[builtins.str]]
        """
        应用名称。
        """
        connection_id: NotRequired[pulumi.Input[builtins.str]]
        """
        元数据连接id。
        """
        connection_type: NotRequired[pulumi.Input[builtins.str]]
        """
        元数据连接类型。BUILT*IN*MYSQL：内置数据库。EXTERNAL*MYSQL：外置数据库。HIVE*METASTORE：HMS。
        """
elif False:
    ClusterApplicationExtraArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterApplicationExtraArgs:
    def __init__(__self__, *,
                 application_component_layouts: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterApplicationExtraApplicationComponentLayoutArgs']]]] = None,
                 application_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterApplicationExtraApplicationConfigArgs']]]] = None,
                 application_name: Optional[pulumi.Input[builtins.str]] = None,
                 connection_id: Optional[pulumi.Input[builtins.str]] = None,
                 connection_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] application_name: 应用名称。
        :param pulumi.Input[builtins.str] connection_id: 元数据连接id。
        :param pulumi.Input[builtins.str] connection_type: 元数据连接类型。BUILT*IN*MYSQL：内置数据库。EXTERNAL*MYSQL：外置数据库。HIVE*METASTORE：HMS。
        """
        if application_component_layouts is not None:
            pulumi.set(__self__, "application_component_layouts", application_component_layouts)
        if application_configs is not None:
            pulumi.set(__self__, "application_configs", application_configs)
        if application_name is not None:
            pulumi.set(__self__, "application_name", application_name)
        if connection_id is not None:
            pulumi.set(__self__, "connection_id", connection_id)
        if connection_type is not None:
            pulumi.set(__self__, "connection_type", connection_type)

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

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

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

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

    @property
    @pulumi.getter(name="applicationName")
    def application_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用名称。
        """
        return pulumi.get(self, "application_name")

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

    @property
    @pulumi.getter(name="connectionId")
    def connection_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        元数据连接id。
        """
        return pulumi.get(self, "connection_id")

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

    @property
    @pulumi.getter(name="connectionType")
    def connection_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        元数据连接类型。BUILT*IN*MYSQL：内置数据库。EXTERNAL*MYSQL：外置数据库。HIVE*METASTORE：HMS。
        """
        return pulumi.get(self, "connection_type")

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


if not MYPY:
    class ClusterApplicationExtraApplicationComponentLayoutArgsDict(TypedDict):
        component_name: NotRequired[pulumi.Input[builtins.str]]
        """
        组件名称。
        """
        effective_scope: NotRequired[pulumi.Input['ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgsDict']]
        """
        组件的布局范围。
        """
elif False:
    ClusterApplicationExtraApplicationComponentLayoutArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterApplicationExtraApplicationComponentLayoutArgs:
    def __init__(__self__, *,
                 component_name: Optional[pulumi.Input[builtins.str]] = None,
                 effective_scope: Optional[pulumi.Input['ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgs']] = None):
        """
        :param pulumi.Input[builtins.str] component_name: 组件名称。
        :param pulumi.Input['ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgs'] effective_scope: 组件的布局范围。
        """
        if component_name is not None:
            pulumi.set(__self__, "component_name", component_name)
        if effective_scope is not None:
            pulumi.set(__self__, "effective_scope", effective_scope)

    @property
    @pulumi.getter(name="componentName")
    def component_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        组件名称。
        """
        return pulumi.get(self, "component_name")

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

    @property
    @pulumi.getter(name="effectiveScope")
    def effective_scope(self) -> Optional[pulumi.Input['ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgs']]:
        """
        组件的布局范围。
        """
        return pulumi.get(self, "effective_scope")

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


if not MYPY:
    class ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgsDict(TypedDict):
        component_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        effective_type: NotRequired[pulumi.Input[builtins.str]]
        """
        生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        """
        node_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        """
        node_group_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        """
        node_group_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        """
        node_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点ID列表，EffectiveType=NODE_ID时，必选。
        """
        node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点名列表，EffectiveType=NODE_NAME时，必选。
        """
elif False:
    ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgs:
    def __init__(__self__, *,
                 component_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 effective_type: Optional[pulumi.Input[builtins.str]] = None,
                 node_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_group_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_group_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] component_names: 组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        :param pulumi.Input[builtins.str] effective_type: 生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_ids: 节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_names: 节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_types: 节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_ids: 节点ID列表，EffectiveType=NODE_ID时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_names: 节点名列表，EffectiveType=NODE_NAME时，必选。
        """
        if component_names is not None:
            pulumi.set(__self__, "component_names", component_names)
        if effective_type is not None:
            pulumi.set(__self__, "effective_type", effective_type)
        if node_group_ids is not None:
            pulumi.set(__self__, "node_group_ids", node_group_ids)
        if node_group_names is not None:
            pulumi.set(__self__, "node_group_names", node_group_names)
        if node_group_types is not None:
            pulumi.set(__self__, "node_group_types", node_group_types)
        if node_ids is not None:
            pulumi.set(__self__, "node_ids", node_ids)
        if node_names is not None:
            pulumi.set(__self__, "node_names", node_names)

    @property
    @pulumi.getter(name="componentNames")
    def component_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        return pulumi.get(self, "component_names")

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

    @property
    @pulumi.getter(name="effectiveType")
    def effective_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        """
        return pulumi.get(self, "effective_type")

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

    @property
    @pulumi.getter(name="nodeGroupIds")
    def node_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        """
        return pulumi.get(self, "node_group_ids")

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

    @property
    @pulumi.getter(name="nodeGroupNames")
    def node_group_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        """
        return pulumi.get(self, "node_group_names")

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

    @property
    @pulumi.getter(name="nodeGroupTypes")
    def node_group_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        """
        return pulumi.get(self, "node_group_types")

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

    @property
    @pulumi.getter(name="nodeIds")
    def node_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点ID列表，EffectiveType=NODE_ID时，必选。
        """
        return pulumi.get(self, "node_ids")

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

    @property
    @pulumi.getter(name="nodeNames")
    def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点名列表，EffectiveType=NODE_NAME时，必选。
        """
        return pulumi.get(self, "node_names")

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


if not MYPY:
    class ClusterApplicationExtraApplicationConfigArgsDict(TypedDict):
        component_instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        组件实例名称。
        """
        component_name: NotRequired[pulumi.Input[builtins.str]]
        """
        组件名称。
        """
        config_file_name: NotRequired[pulumi.Input[builtins.str]]
        """
        配置文件名。
        """
        config_item_key: NotRequired[pulumi.Input[builtins.str]]
        """
        配置项名称。
        """
        config_item_value: NotRequired[pulumi.Input[builtins.str]]
        """
        配置项值。
        """
        deleted: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否删除。
        """
        effective_scope: NotRequired[pulumi.Input['ClusterApplicationExtraApplicationConfigEffectiveScopeArgsDict']]
        """
        影响组件。
        """
elif False:
    ClusterApplicationExtraApplicationConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterApplicationExtraApplicationConfigArgs:
    def __init__(__self__, *,
                 component_instance_name: Optional[pulumi.Input[builtins.str]] = None,
                 component_name: Optional[pulumi.Input[builtins.str]] = None,
                 config_file_name: Optional[pulumi.Input[builtins.str]] = None,
                 config_item_key: Optional[pulumi.Input[builtins.str]] = None,
                 config_item_value: Optional[pulumi.Input[builtins.str]] = None,
                 deleted: Optional[pulumi.Input[builtins.bool]] = None,
                 effective_scope: Optional[pulumi.Input['ClusterApplicationExtraApplicationConfigEffectiveScopeArgs']] = None):
        """
        :param pulumi.Input[builtins.str] component_instance_name: 组件实例名称。
        :param pulumi.Input[builtins.str] component_name: 组件名称。
        :param pulumi.Input[builtins.str] config_file_name: 配置文件名。
        :param pulumi.Input[builtins.str] config_item_key: 配置项名称。
        :param pulumi.Input[builtins.str] config_item_value: 配置项值。
        :param pulumi.Input[builtins.bool] deleted: 是否删除。
        :param pulumi.Input['ClusterApplicationExtraApplicationConfigEffectiveScopeArgs'] effective_scope: 影响组件。
        """
        if component_instance_name is not None:
            pulumi.set(__self__, "component_instance_name", component_instance_name)
        if component_name is not None:
            pulumi.set(__self__, "component_name", component_name)
        if config_file_name is not None:
            pulumi.set(__self__, "config_file_name", config_file_name)
        if config_item_key is not None:
            pulumi.set(__self__, "config_item_key", config_item_key)
        if config_item_value is not None:
            pulumi.set(__self__, "config_item_value", config_item_value)
        if deleted is not None:
            pulumi.set(__self__, "deleted", deleted)
        if effective_scope is not None:
            pulumi.set(__self__, "effective_scope", effective_scope)

    @property
    @pulumi.getter(name="componentInstanceName")
    def component_instance_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        组件实例名称。
        """
        return pulumi.get(self, "component_instance_name")

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

    @property
    @pulumi.getter(name="componentName")
    def component_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        组件名称。
        """
        return pulumi.get(self, "component_name")

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

    @property
    @pulumi.getter(name="configFileName")
    def config_file_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        配置文件名。
        """
        return pulumi.get(self, "config_file_name")

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

    @property
    @pulumi.getter(name="configItemKey")
    def config_item_key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        配置项名称。
        """
        return pulumi.get(self, "config_item_key")

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

    @property
    @pulumi.getter(name="configItemValue")
    def config_item_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        配置项值。
        """
        return pulumi.get(self, "config_item_value")

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

    @property
    @pulumi.getter
    def deleted(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否删除。
        """
        return pulumi.get(self, "deleted")

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

    @property
    @pulumi.getter(name="effectiveScope")
    def effective_scope(self) -> Optional[pulumi.Input['ClusterApplicationExtraApplicationConfigEffectiveScopeArgs']]:
        """
        影响组件。
        """
        return pulumi.get(self, "effective_scope")

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


if not MYPY:
    class ClusterApplicationExtraApplicationConfigEffectiveScopeArgsDict(TypedDict):
        component_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        effective_type: NotRequired[pulumi.Input[builtins.str]]
        """
        生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        """
        node_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        """
        node_group_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        """
        node_group_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        """
        node_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点ID列表，EffectiveType=NODE_ID时，必选。
        """
        node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点名列表，EffectiveType=NODE_NAME时，必选。
        """
elif False:
    ClusterApplicationExtraApplicationConfigEffectiveScopeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterApplicationExtraApplicationConfigEffectiveScopeArgs:
    def __init__(__self__, *,
                 component_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 effective_type: Optional[pulumi.Input[builtins.str]] = None,
                 node_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_group_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_group_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] component_names: 组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        :param pulumi.Input[builtins.str] effective_type: 生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_ids: 节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_names: 节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_types: 节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_ids: 节点ID列表，EffectiveType=NODE_ID时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_names: 节点名列表，EffectiveType=NODE_NAME时，必选。
        """
        if component_names is not None:
            pulumi.set(__self__, "component_names", component_names)
        if effective_type is not None:
            pulumi.set(__self__, "effective_type", effective_type)
        if node_group_ids is not None:
            pulumi.set(__self__, "node_group_ids", node_group_ids)
        if node_group_names is not None:
            pulumi.set(__self__, "node_group_names", node_group_names)
        if node_group_types is not None:
            pulumi.set(__self__, "node_group_types", node_group_types)
        if node_ids is not None:
            pulumi.set(__self__, "node_ids", node_ids)
        if node_names is not None:
            pulumi.set(__self__, "node_names", node_names)

    @property
    @pulumi.getter(name="componentNames")
    def component_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        return pulumi.get(self, "component_names")

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

    @property
    @pulumi.getter(name="effectiveType")
    def effective_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        """
        return pulumi.get(self, "effective_type")

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

    @property
    @pulumi.getter(name="nodeGroupIds")
    def node_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        """
        return pulumi.get(self, "node_group_ids")

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

    @property
    @pulumi.getter(name="nodeGroupNames")
    def node_group_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        """
        return pulumi.get(self, "node_group_names")

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

    @property
    @pulumi.getter(name="nodeGroupTypes")
    def node_group_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        """
        return pulumi.get(self, "node_group_types")

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

    @property
    @pulumi.getter(name="nodeIds")
    def node_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点ID列表，EffectiveType=NODE_ID时，必选。
        """
        return pulumi.get(self, "node_ids")

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

    @property
    @pulumi.getter(name="nodeNames")
    def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点名列表，EffectiveType=NODE_NAME时，必选。
        """
        return pulumi.get(self, "node_names")

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


if not MYPY:
    class ClusterBootstrapScriptArgsDict(TypedDict):
        effective_scope: NotRequired[pulumi.Input['ClusterBootstrapScriptEffectiveScopeArgsDict']]
        """
        脚本执行范围。
        """
        execution_fail_strategy: NotRequired[pulumi.Input[builtins.str]]
        """
        执行失败策略。取值范围：FAILED*CONTINUE：失败后继续执行其他任务。FAILED*BLOCK：失败后中断，不再继续执行后续任务。当脚本为BOOTSTRAP时，会导致创建集群、扩容节点组操作中断并失败。默认值：FAILED_BLOCK。
        """
        execution_moment: NotRequired[pulumi.Input[builtins.str]]
        """
        脚本的执行时机。仅scriptType=BOOTSTRAP时生效。BEFORE*APPLICATION*INSTALL：应用安装前。AFTER*APPLICATION*STARTED：应用启动后。默认值：BEFORE*APP*INSTALL
        """
        priority: NotRequired[pulumi.Input[builtins.str]]
        """
        脚本执行优先级。取值范围：1~1000。默认值1。
        """
        script_args: NotRequired[pulumi.Input[builtins.str]]
        """
        脚本参数。
        """
        script_name: NotRequired[pulumi.Input[builtins.str]]
        """
        脚本名称。必填。长度为1~128个字符，必须以大小字母或中文开头，不能以 http:： 和 https:： 开头。可以包含中文、英文、数字、下划线（_）、或者短划线（-）。
        """
        script_path: NotRequired[pulumi.Input[builtins.str]]
        """
        脚本所在TOS路径。必填。以 tos:： 开头。
        """
        script_type: NotRequired[pulumi.Input[builtins.str]]
        """
        脚本类型。NORMAL：普通脚本。BOOTSTRAP：引导脚本。
        """
elif False:
    ClusterBootstrapScriptArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterBootstrapScriptArgs:
    def __init__(__self__, *,
                 effective_scope: Optional[pulumi.Input['ClusterBootstrapScriptEffectiveScopeArgs']] = None,
                 execution_fail_strategy: Optional[pulumi.Input[builtins.str]] = None,
                 execution_moment: Optional[pulumi.Input[builtins.str]] = None,
                 priority: Optional[pulumi.Input[builtins.str]] = None,
                 script_args: Optional[pulumi.Input[builtins.str]] = None,
                 script_name: Optional[pulumi.Input[builtins.str]] = None,
                 script_path: Optional[pulumi.Input[builtins.str]] = None,
                 script_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['ClusterBootstrapScriptEffectiveScopeArgs'] effective_scope: 脚本执行范围。
        :param pulumi.Input[builtins.str] execution_fail_strategy: 执行失败策略。取值范围：FAILED*CONTINUE：失败后继续执行其他任务。FAILED*BLOCK：失败后中断，不再继续执行后续任务。当脚本为BOOTSTRAP时，会导致创建集群、扩容节点组操作中断并失败。默认值：FAILED_BLOCK。
        :param pulumi.Input[builtins.str] execution_moment: 脚本的执行时机。仅scriptType=BOOTSTRAP时生效。BEFORE*APPLICATION*INSTALL：应用安装前。AFTER*APPLICATION*STARTED：应用启动后。默认值：BEFORE*APP*INSTALL
        :param pulumi.Input[builtins.str] priority: 脚本执行优先级。取值范围：1~1000。默认值1。
        :param pulumi.Input[builtins.str] script_args: 脚本参数。
        :param pulumi.Input[builtins.str] script_name: 脚本名称。必填。长度为1~128个字符，必须以大小字母或中文开头，不能以 http:： 和 https:： 开头。可以包含中文、英文、数字、下划线（_）、或者短划线（-）。
        :param pulumi.Input[builtins.str] script_path: 脚本所在TOS路径。必填。以 tos:： 开头。
        :param pulumi.Input[builtins.str] script_type: 脚本类型。NORMAL：普通脚本。BOOTSTRAP：引导脚本。
        """
        if effective_scope is not None:
            pulumi.set(__self__, "effective_scope", effective_scope)
        if execution_fail_strategy is not None:
            pulumi.set(__self__, "execution_fail_strategy", execution_fail_strategy)
        if execution_moment is not None:
            pulumi.set(__self__, "execution_moment", execution_moment)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)
        if script_args is not None:
            pulumi.set(__self__, "script_args", script_args)
        if script_name is not None:
            pulumi.set(__self__, "script_name", script_name)
        if script_path is not None:
            pulumi.set(__self__, "script_path", script_path)
        if script_type is not None:
            pulumi.set(__self__, "script_type", script_type)

    @property
    @pulumi.getter(name="effectiveScope")
    def effective_scope(self) -> Optional[pulumi.Input['ClusterBootstrapScriptEffectiveScopeArgs']]:
        """
        脚本执行范围。
        """
        return pulumi.get(self, "effective_scope")

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

    @property
    @pulumi.getter(name="executionFailStrategy")
    def execution_fail_strategy(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        执行失败策略。取值范围：FAILED*CONTINUE：失败后继续执行其他任务。FAILED*BLOCK：失败后中断，不再继续执行后续任务。当脚本为BOOTSTRAP时，会导致创建集群、扩容节点组操作中断并失败。默认值：FAILED_BLOCK。
        """
        return pulumi.get(self, "execution_fail_strategy")

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

    @property
    @pulumi.getter(name="executionMoment")
    def execution_moment(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        脚本的执行时机。仅scriptType=BOOTSTRAP时生效。BEFORE*APPLICATION*INSTALL：应用安装前。AFTER*APPLICATION*STARTED：应用启动后。默认值：BEFORE*APP*INSTALL
        """
        return pulumi.get(self, "execution_moment")

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

    @property
    @pulumi.getter
    def priority(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        脚本执行优先级。取值范围：1~1000。默认值1。
        """
        return pulumi.get(self, "priority")

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

    @property
    @pulumi.getter(name="scriptArgs")
    def script_args(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        脚本参数。
        """
        return pulumi.get(self, "script_args")

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

    @property
    @pulumi.getter(name="scriptName")
    def script_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        脚本名称。必填。长度为1~128个字符，必须以大小字母或中文开头，不能以 http:： 和 https:： 开头。可以包含中文、英文、数字、下划线（_）、或者短划线（-）。
        """
        return pulumi.get(self, "script_name")

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

    @property
    @pulumi.getter(name="scriptPath")
    def script_path(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        脚本所在TOS路径。必填。以 tos:： 开头。
        """
        return pulumi.get(self, "script_path")

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

    @property
    @pulumi.getter(name="scriptType")
    def script_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        脚本类型。NORMAL：普通脚本。BOOTSTRAP：引导脚本。
        """
        return pulumi.get(self, "script_type")

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


if not MYPY:
    class ClusterBootstrapScriptEffectiveScopeArgsDict(TypedDict):
        component_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        effective_type: NotRequired[pulumi.Input[builtins.str]]
        """
        生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        """
        node_group_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        """
        node_group_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        """
        node_group_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        """
        node_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点ID列表，EffectiveType=NODE_ID时，必选。
        """
        node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点名列表，EffectiveType=NODE_NAME时，必选。
        """
elif False:
    ClusterBootstrapScriptEffectiveScopeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterBootstrapScriptEffectiveScopeArgs:
    def __init__(__self__, *,
                 component_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 effective_type: Optional[pulumi.Input[builtins.str]] = None,
                 node_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_group_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_group_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 node_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] component_names: 组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        :param pulumi.Input[builtins.str] effective_type: 生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_ids: 节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_names: 节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_group_types: 节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_ids: 节点ID列表，EffectiveType=NODE_ID时，必选。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_names: 节点名列表，EffectiveType=NODE_NAME时，必选。
        """
        if component_names is not None:
            pulumi.set(__self__, "component_names", component_names)
        if effective_type is not None:
            pulumi.set(__self__, "effective_type", effective_type)
        if node_group_ids is not None:
            pulumi.set(__self__, "node_group_ids", node_group_ids)
        if node_group_names is not None:
            pulumi.set(__self__, "node_group_names", node_group_names)
        if node_group_types is not None:
            pulumi.set(__self__, "node_group_types", node_group_types)
        if node_ids is not None:
            pulumi.set(__self__, "node_ids", node_ids)
        if node_names is not None:
            pulumi.set(__self__, "node_names", node_names)

    @property
    @pulumi.getter(name="componentNames")
    def component_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        return pulumi.get(self, "component_names")

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

    @property
    @pulumi.getter(name="effectiveType")
    def effective_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        """
        return pulumi.get(self, "effective_type")

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

    @property
    @pulumi.getter(name="nodeGroupIds")
    def node_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        """
        return pulumi.get(self, "node_group_ids")

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

    @property
    @pulumi.getter(name="nodeGroupNames")
    def node_group_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        """
        return pulumi.get(self, "node_group_names")

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

    @property
    @pulumi.getter(name="nodeGroupTypes")
    def node_group_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        """
        return pulumi.get(self, "node_group_types")

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

    @property
    @pulumi.getter(name="nodeIds")
    def node_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点ID列表，EffectiveType=NODE_ID时，必选。
        """
        return pulumi.get(self, "node_ids")

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

    @property
    @pulumi.getter(name="nodeNames")
    def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点名列表，EffectiveType=NODE_NAME时，必选。
        """
        return pulumi.get(self, "node_names")

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


if not MYPY:
    class ClusterChargePreConfigArgsDict(TypedDict):
        auto_renew: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启自动续费。取值范围：true：开启。false：不开启。
        """
        auto_renew_period: NotRequired[pulumi.Input[builtins.int]]
        """
        自动续费触发时的续费时长，当AutoRenew=true时，默认值=1。
        """
        auto_renew_period_unit: NotRequired[pulumi.Input[builtins.str]]
        """
        自动续费触发时的续费时长单位，当AutoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        charge_period: NotRequired[pulumi.Input[builtins.int]]
        """
        chargeType=PRE默认值=1，包月的购买时长单位。
        """
        charge_period_unit: NotRequired[pulumi.Input[builtins.str]]
        """
        chargeType=PRE时，默认值=Month，包月的购买时长单位，取值范围：Month：月。Year：年。
        """
        charge_type: NotRequired[pulumi.Input[builtins.str]]
        """
        付费类型，取值范围：PRE，POST。
        """
elif False:
    ClusterChargePreConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterChargePreConfigArgs:
    def __init__(__self__, *,
                 auto_renew: Optional[pulumi.Input[builtins.bool]] = None,
                 auto_renew_period: Optional[pulumi.Input[builtins.int]] = None,
                 auto_renew_period_unit: Optional[pulumi.Input[builtins.str]] = None,
                 charge_period: Optional[pulumi.Input[builtins.int]] = None,
                 charge_period_unit: Optional[pulumi.Input[builtins.str]] = None,
                 charge_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] auto_renew: 是否开启自动续费。取值范围：true：开启。false：不开启。
        :param pulumi.Input[builtins.int] auto_renew_period: 自动续费触发时的续费时长，当AutoRenew=true时，默认值=1。
        :param pulumi.Input[builtins.str] auto_renew_period_unit: 自动续费触发时的续费时长单位，当AutoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        :param pulumi.Input[builtins.int] charge_period: chargeType=PRE默认值=1，包月的购买时长单位。
        :param pulumi.Input[builtins.str] charge_period_unit: chargeType=PRE时，默认值=Month，包月的购买时长单位，取值范围：Month：月。Year：年。
        :param pulumi.Input[builtins.str] charge_type: 付费类型，取值范围：PRE，POST。
        """
        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 auto_renew_period_unit is not None:
            pulumi.set(__self__, "auto_renew_period_unit", auto_renew_period_unit)
        if charge_period is not None:
            pulumi.set(__self__, "charge_period", charge_period)
        if charge_period_unit is not None:
            pulumi.set(__self__, "charge_period_unit", charge_period_unit)
        if charge_type is not None:
            pulumi.set(__self__, "charge_type", charge_type)

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启自动续费。取值范围：true：开启。false：不开启。
        """
        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时，默认值=1。
        """
        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="autoRenewPeriodUnit")
    def auto_renew_period_unit(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自动续费触发时的续费时长单位，当AutoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "auto_renew_period_unit")

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

    @property
    @pulumi.getter(name="chargePeriod")
    def charge_period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        chargeType=PRE默认值=1，包月的购买时长单位。
        """
        return pulumi.get(self, "charge_period")

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

    @property
    @pulumi.getter(name="chargePeriodUnit")
    def charge_period_unit(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        chargeType=PRE时，默认值=Month，包月的购买时长单位，取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "charge_period_unit")

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

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        付费类型，取值范围：PRE，POST。
        """
        return pulumi.get(self, "charge_type")

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


if not MYPY:
    class ClusterNodeAttributeArgsDict(TypedDict):
        ecs_iam_role: NotRequired[pulumi.Input[builtins.str]]
        """
        ECS实例角色。
        """
        zone_id: NotRequired[pulumi.Input[builtins.str]]
        """
        可用区ID。
        """
elif False:
    ClusterNodeAttributeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterNodeAttributeArgs:
    def __init__(__self__, *,
                 ecs_iam_role: Optional[pulumi.Input[builtins.str]] = None,
                 zone_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] ecs_iam_role: ECS实例角色。
        :param pulumi.Input[builtins.str] zone_id: 可用区ID。
        """
        if ecs_iam_role is not None:
            pulumi.set(__self__, "ecs_iam_role", ecs_iam_role)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="ecsIamRole")
    def ecs_iam_role(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        ECS实例角色。
        """
        return pulumi.get(self, "ecs_iam_role")

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

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        可用区ID。
        """
        return pulumi.get(self, "zone_id")

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


if not MYPY:
    class ClusterNodeGroupAttributeArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        公网带宽。默认值 8M。后续如果用户侧调整了，emr侧需要同步该信息。
        """
        charge_type: NotRequired[pulumi.Input[builtins.str]]
        """
        节点组付费类型。为空时，复用集群的chargeType。Master、Core组必须复用集群维度的付费类型。当集群的chargeType为PRE时，task节点组的chargeType允许设置为POST；当集群的chargeType为POST时，节点组的chargeType默认为POST，节点组上的此参数设置无效。
        """
        data_disks: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClusterNodeGroupAttributeDataDiskArgsDict']]]]
        ecs_instance_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        节点组的ecs机型列表。当前只支持设置1个机型。即List的长度限制为1。
        """
        ecs_key_pair_name: NotRequired[pulumi.Input[builtins.str]]
        """
        ecs的密钥对名称。
        """
        ecs_password: NotRequired[pulumi.Input[builtins.str]]
        """
        Ecs root账号的密码。
        """
        node_count: NotRequired[pulumi.Input[builtins.int]]
        """
        节点组当前期望购买的节点数量。
        """
        node_group_name: NotRequired[pulumi.Input[builtins.str]]
        """
        长度为1~128个字符，不能以 http:： 和 https:： 开头。可以包含中文、英文、数字、下划线（_）、或者短划线（-）。
        """
        node_group_type: NotRequired[pulumi.Input[builtins.str]]
        """
        节点组类型。
        """
        subnet_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        子网Id列表，目前只能传递一个参数，且各节点组的子网Id都是相同的。
        """
        system_disk: NotRequired[pulumi.Input['ClusterNodeGroupAttributeSystemDiskArgsDict']]
        """
        系统盘配置。
        """
        with_public_ip: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否挂载公网ip。
        """
        zone_id: NotRequired[pulumi.Input[builtins.str]]
        """
        可用区ID。
        """
elif False:
    ClusterNodeGroupAttributeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterNodeGroupAttributeArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 charge_type: Optional[pulumi.Input[builtins.str]] = None,
                 data_disks: Optional[pulumi.Input[Sequence[pulumi.Input['ClusterNodeGroupAttributeDataDiskArgs']]]] = None,
                 ecs_instance_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 ecs_key_pair_name: Optional[pulumi.Input[builtins.str]] = None,
                 ecs_password: Optional[pulumi.Input[builtins.str]] = None,
                 node_count: Optional[pulumi.Input[builtins.int]] = None,
                 node_group_name: Optional[pulumi.Input[builtins.str]] = None,
                 node_group_type: Optional[pulumi.Input[builtins.str]] = None,
                 subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 system_disk: Optional[pulumi.Input['ClusterNodeGroupAttributeSystemDiskArgs']] = None,
                 with_public_ip: Optional[pulumi.Input[builtins.bool]] = None,
                 zone_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: 公网带宽。默认值 8M。后续如果用户侧调整了，emr侧需要同步该信息。
        :param pulumi.Input[builtins.str] charge_type: 节点组付费类型。为空时，复用集群的chargeType。Master、Core组必须复用集群维度的付费类型。当集群的chargeType为PRE时，task节点组的chargeType允许设置为POST；当集群的chargeType为POST时，节点组的chargeType默认为POST，节点组上的此参数设置无效。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ecs_instance_types: 节点组的ecs机型列表。当前只支持设置1个机型。即List的长度限制为1。
        :param pulumi.Input[builtins.str] ecs_key_pair_name: ecs的密钥对名称。
        :param pulumi.Input[builtins.str] ecs_password: Ecs root账号的密码。
        :param pulumi.Input[builtins.int] node_count: 节点组当前期望购买的节点数量。
        :param pulumi.Input[builtins.str] node_group_name: 长度为1~128个字符，不能以 http:： 和 https:： 开头。可以包含中文、英文、数字、下划线（_）、或者短划线（-）。
        :param pulumi.Input[builtins.str] node_group_type: 节点组类型。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] subnet_ids: 子网Id列表，目前只能传递一个参数，且各节点组的子网Id都是相同的。
        :param pulumi.Input['ClusterNodeGroupAttributeSystemDiskArgs'] system_disk: 系统盘配置。
        :param pulumi.Input[builtins.bool] with_public_ip: 是否挂载公网ip。
        :param pulumi.Input[builtins.str] zone_id: 可用区ID。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if charge_type is not None:
            pulumi.set(__self__, "charge_type", charge_type)
        if data_disks is not None:
            pulumi.set(__self__, "data_disks", data_disks)
        if ecs_instance_types is not None:
            pulumi.set(__self__, "ecs_instance_types", ecs_instance_types)
        if ecs_key_pair_name is not None:
            pulumi.set(__self__, "ecs_key_pair_name", ecs_key_pair_name)
        if ecs_password is not None:
            pulumi.set(__self__, "ecs_password", ecs_password)
        if node_count is not None:
            pulumi.set(__self__, "node_count", node_count)
        if node_group_name is not None:
            pulumi.set(__self__, "node_group_name", node_group_name)
        if node_group_type is not None:
            pulumi.set(__self__, "node_group_type", node_group_type)
        if subnet_ids is not None:
            pulumi.set(__self__, "subnet_ids", subnet_ids)
        if system_disk is not None:
            pulumi.set(__self__, "system_disk", system_disk)
        if with_public_ip is not None:
            pulumi.set(__self__, "with_public_ip", with_public_ip)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网带宽。默认值 8M。后续如果用户侧调整了，emr侧需要同步该信息。
        """
        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="chargeType")
    def charge_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点组付费类型。为空时，复用集群的chargeType。Master、Core组必须复用集群维度的付费类型。当集群的chargeType为PRE时，task节点组的chargeType允许设置为POST；当集群的chargeType为POST时，节点组的chargeType默认为POST，节点组上的此参数设置无效。
        """
        return pulumi.get(self, "charge_type")

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

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

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

    @property
    @pulumi.getter(name="ecsInstanceTypes")
    def ecs_instance_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        节点组的ecs机型列表。当前只支持设置1个机型。即List的长度限制为1。
        """
        return pulumi.get(self, "ecs_instance_types")

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

    @property
    @pulumi.getter(name="ecsKeyPairName")
    def ecs_key_pair_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        ecs的密钥对名称。
        """
        return pulumi.get(self, "ecs_key_pair_name")

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

    @property
    @pulumi.getter(name="ecsPassword")
    def ecs_password(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Ecs root账号的密码。
        """
        return pulumi.get(self, "ecs_password")

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

    @property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点组当前期望购买的节点数量。
        """
        return pulumi.get(self, "node_count")

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

    @property
    @pulumi.getter(name="nodeGroupName")
    def node_group_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        长度为1~128个字符，不能以 http:： 和 https:： 开头。可以包含中文、英文、数字、下划线（_）、或者短划线（-）。
        """
        return pulumi.get(self, "node_group_name")

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

    @property
    @pulumi.getter(name="nodeGroupType")
    def node_group_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点组类型。
        """
        return pulumi.get(self, "node_group_type")

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

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        子网Id列表，目前只能传递一个参数，且各节点组的子网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="systemDisk")
    def system_disk(self) -> Optional[pulumi.Input['ClusterNodeGroupAttributeSystemDiskArgs']]:
        """
        系统盘配置。
        """
        return pulumi.get(self, "system_disk")

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

    @property
    @pulumi.getter(name="withPublicIp")
    def with_public_ip(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否挂载公网ip。
        """
        return pulumi.get(self, "with_public_ip")

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

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        可用区ID。
        """
        return pulumi.get(self, "zone_id")

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


if not MYPY:
    class ClusterNodeGroupAttributeDataDiskArgsDict(TypedDict):
        count: NotRequired[pulumi.Input[builtins.int]]
        """
        磁盘块数，默认值4，最大15，最小1。
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV
        """
elif False:
    ClusterNodeGroupAttributeDataDiskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterNodeGroupAttributeDataDiskArgs:
    def __init__(__self__, *,
                 count: Optional[pulumi.Input[builtins.int]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 volume_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] count: 磁盘块数，默认值4，最大15，最小1。
        :param pulumi.Input[builtins.int] size: 磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param pulumi.Input[builtins.str] volume_type: 磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        磁盘块数，默认值4，最大15，最小1。
        """
        return pulumi.get(self, "count")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        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="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV
        """
        return pulumi.get(self, "volume_type")

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


if not MYPY:
    class ClusterNodeGroupAttributeSystemDiskArgsDict(TypedDict):
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        磁盘大小。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        磁盘类型。
        """
elif False:
    ClusterNodeGroupAttributeSystemDiskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterNodeGroupAttributeSystemDiskArgs:
    def __init__(__self__, *,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 volume_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] size: 磁盘大小。
        :param pulumi.Input[builtins.str] volume_type: 磁盘类型。
        """
        if size is not None:
            pulumi.set(__self__, "size", size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        磁盘大小。
        """
        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="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        磁盘类型。
        """
        return pulumi.get(self, "volume_type")

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


if not MYPY:
    class ClusterStateChangeReasonArgsDict(TypedDict):
        code: NotRequired[pulumi.Input[builtins.str]]
        """
        状态更新码。
        """
        reason: NotRequired[pulumi.Input[builtins.str]]
        """
        状态更新原因。
        """
elif False:
    ClusterStateChangeReasonArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterStateChangeReasonArgs:
    def __init__(__self__, *,
                 code: Optional[pulumi.Input[builtins.str]] = None,
                 reason: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] code: 状态更新码。
        :param pulumi.Input[builtins.str] reason: 状态更新原因。
        """
        if code is not None:
            pulumi.set(__self__, "code", code)
        if reason is not None:
            pulumi.set(__self__, "reason", reason)

    @property
    @pulumi.getter
    def code(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        状态更新码。
        """
        return pulumi.get(self, "code")

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

    @property
    @pulumi.getter
    def reason(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        状态更新原因。
        """
        return pulumi.get(self, "reason")

    @reason.setter
    def reason(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "reason", 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 NodeGroupApplicationLayoutArgsDict(TypedDict):
        application_name: NotRequired[pulumi.Input[builtins.str]]
        """
        应用名称。
        """
        layout_component_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        组件的自定义配置参数列表。
        """
elif False:
    NodeGroupApplicationLayoutArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodeGroupApplicationLayoutArgs:
    def __init__(__self__, *,
                 application_name: Optional[pulumi.Input[builtins.str]] = None,
                 layout_component_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.str] application_name: 应用名称。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] layout_component_names: 组件的自定义配置参数列表。
        """
        if application_name is not None:
            pulumi.set(__self__, "application_name", application_name)
        if layout_component_names is not None:
            pulumi.set(__self__, "layout_component_names", layout_component_names)

    @property
    @pulumi.getter(name="applicationName")
    def application_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        应用名称。
        """
        return pulumi.get(self, "application_name")

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

    @property
    @pulumi.getter(name="layoutComponentNames")
    def layout_component_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        组件的自定义配置参数列表。
        """
        return pulumi.get(self, "layout_component_names")

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


if not MYPY:
    class NodeGroupChargePreConfigArgsDict(TypedDict):
        auto_renew: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启自动续费。
        """
        auto_renew_period: NotRequired[pulumi.Input[builtins.int]]
        """
        自动续费触发时的续费时长，当autoRenew=true时，默认值=1。
        """
        auto_renew_period_unit: NotRequired[pulumi.Input[builtins.str]]
        """
        自动续费触发时的续费时长单位，当autoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        charge_period: NotRequired[pulumi.Input[builtins.int]]
        """
        chargeType=PRE默认值=1，包月的购买时长单位。
        """
        charge_period_unit: NotRequired[pulumi.Input[builtins.str]]
        """
        chargeType=PRE时，默认值=Month，包月的购买时长单位。取值范围：Month：月。Year：年。
        """
        charge_type: NotRequired[pulumi.Input[builtins.str]]
        """
        付费类型，枚举值：POST，PRE。
        """
elif False:
    NodeGroupChargePreConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodeGroupChargePreConfigArgs:
    def __init__(__self__, *,
                 auto_renew: Optional[pulumi.Input[builtins.bool]] = None,
                 auto_renew_period: Optional[pulumi.Input[builtins.int]] = None,
                 auto_renew_period_unit: Optional[pulumi.Input[builtins.str]] = None,
                 charge_period: Optional[pulumi.Input[builtins.int]] = None,
                 charge_period_unit: Optional[pulumi.Input[builtins.str]] = None,
                 charge_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] auto_renew: 是否开启自动续费。
        :param pulumi.Input[builtins.int] auto_renew_period: 自动续费触发时的续费时长，当autoRenew=true时，默认值=1。
        :param pulumi.Input[builtins.str] auto_renew_period_unit: 自动续费触发时的续费时长单位，当autoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        :param pulumi.Input[builtins.int] charge_period: chargeType=PRE默认值=1，包月的购买时长单位。
        :param pulumi.Input[builtins.str] charge_period_unit: chargeType=PRE时，默认值=Month，包月的购买时长单位。取值范围：Month：月。Year：年。
        :param pulumi.Input[builtins.str] charge_type: 付费类型，枚举值：POST，PRE。
        """
        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 auto_renew_period_unit is not None:
            pulumi.set(__self__, "auto_renew_period_unit", auto_renew_period_unit)
        if charge_period is not None:
            pulumi.set(__self__, "charge_period", charge_period)
        if charge_period_unit is not None:
            pulumi.set(__self__, "charge_period_unit", charge_period_unit)
        if charge_type is not None:
            pulumi.set(__self__, "charge_type", charge_type)

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启自动续费。
        """
        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时，默认值=1。
        """
        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="autoRenewPeriodUnit")
    def auto_renew_period_unit(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自动续费触发时的续费时长单位，当autoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "auto_renew_period_unit")

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

    @property
    @pulumi.getter(name="chargePeriod")
    def charge_period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        chargeType=PRE默认值=1，包月的购买时长单位。
        """
        return pulumi.get(self, "charge_period")

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

    @property
    @pulumi.getter(name="chargePeriodUnit")
    def charge_period_unit(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        chargeType=PRE时，默认值=Month，包月的购买时长单位。取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "charge_period_unit")

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

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        付费类型，枚举值：POST，PRE。
        """
        return pulumi.get(self, "charge_type")

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


if not MYPY:
    class NodeGroupDataDiskArgsDict(TypedDict):
        count: NotRequired[pulumi.Input[builtins.int]]
        """
        磁盘块数，默认值4，最大15，最小1。
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV。
        """
elif False:
    NodeGroupDataDiskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodeGroupDataDiskArgs:
    def __init__(__self__, *,
                 count: Optional[pulumi.Input[builtins.int]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 volume_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] count: 磁盘块数，默认值4，最大15，最小1。
        :param pulumi.Input[builtins.int] size: 磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param pulumi.Input[builtins.str] volume_type: 磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV。
        """
        if count is not None:
            pulumi.set(__self__, "count", count)
        if size is not None:
            pulumi.set(__self__, "size", size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        磁盘块数，默认值4，最大15，最小1。
        """
        return pulumi.get(self, "count")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        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="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV。
        """
        return pulumi.get(self, "volume_type")

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


if not MYPY:
    class NodeGroupNodeArgsDict(TypedDict):
        created_time: NotRequired[pulumi.Input[builtins.int]]
        """
        节点创建时间。
        """
        ecs_instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        ecs实例规格。
        """
        node_fqdn: NotRequired[pulumi.Input[builtins.str]]
        """
        节点FQDN。
        """
        node_id: NotRequired[pulumi.Input[builtins.str]]
        """
        节点ID。
        """
        node_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点名称。
        """
        node_state: NotRequired[pulumi.Input[builtins.str]]
        """
        节点状态。UNKNOWN：未知状态。CREATING：创建中。RUNNING：运行中。STOPPING：停止中。STOPPED：已停止。REBOOTING：重启中。DELETED：已删除。
        """
        private_ip: NotRequired[pulumi.Input[builtins.str]]
        """
        私有IP。
        """
        public_ip: NotRequired[pulumi.Input[builtins.str]]
        """
        公网IP。
        """
        ready_time: NotRequired[pulumi.Input[builtins.int]]
        """
        准备完毕时间。
        """
        terminate_time: NotRequired[pulumi.Input[builtins.int]]
        """
        集群终止时间。
        """
elif False:
    NodeGroupNodeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodeGroupNodeArgs:
    def __init__(__self__, *,
                 created_time: Optional[pulumi.Input[builtins.int]] = None,
                 ecs_instance_type: Optional[pulumi.Input[builtins.str]] = None,
                 node_fqdn: Optional[pulumi.Input[builtins.str]] = None,
                 node_id: Optional[pulumi.Input[builtins.str]] = None,
                 node_name: Optional[pulumi.Input[builtins.str]] = None,
                 node_state: Optional[pulumi.Input[builtins.str]] = None,
                 private_ip: Optional[pulumi.Input[builtins.str]] = None,
                 public_ip: Optional[pulumi.Input[builtins.str]] = None,
                 ready_time: Optional[pulumi.Input[builtins.int]] = None,
                 terminate_time: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] created_time: 节点创建时间。
        :param pulumi.Input[builtins.str] ecs_instance_type: ecs实例规格。
        :param pulumi.Input[builtins.str] node_fqdn: 节点FQDN。
        :param pulumi.Input[builtins.str] node_id: 节点ID。
        :param pulumi.Input[builtins.str] node_name: 节点名称。
        :param pulumi.Input[builtins.str] node_state: 节点状态。UNKNOWN：未知状态。CREATING：创建中。RUNNING：运行中。STOPPING：停止中。STOPPED：已停止。REBOOTING：重启中。DELETED：已删除。
        :param pulumi.Input[builtins.str] private_ip: 私有IP。
        :param pulumi.Input[builtins.str] public_ip: 公网IP。
        :param pulumi.Input[builtins.int] ready_time: 准备完毕时间。
        :param pulumi.Input[builtins.int] terminate_time: 集群终止时间。
        """
        if created_time is not None:
            pulumi.set(__self__, "created_time", created_time)
        if ecs_instance_type is not None:
            pulumi.set(__self__, "ecs_instance_type", ecs_instance_type)
        if node_fqdn is not None:
            pulumi.set(__self__, "node_fqdn", node_fqdn)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if node_name is not None:
            pulumi.set(__self__, "node_name", node_name)
        if node_state is not None:
            pulumi.set(__self__, "node_state", node_state)
        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)
        if ready_time is not None:
            pulumi.set(__self__, "ready_time", ready_time)
        if terminate_time is not None:
            pulumi.set(__self__, "terminate_time", terminate_time)

    @property
    @pulumi.getter(name="createdTime")
    def created_time(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点创建时间。
        """
        return pulumi.get(self, "created_time")

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

    @property
    @pulumi.getter(name="ecsInstanceType")
    def ecs_instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        ecs实例规格。
        """
        return pulumi.get(self, "ecs_instance_type")

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

    @property
    @pulumi.getter(name="nodeFqdn")
    def node_fqdn(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点FQDN。
        """
        return pulumi.get(self, "node_fqdn")

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

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点ID。
        """
        return pulumi.get(self, "node_id")

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

    @property
    @pulumi.getter(name="nodeName")
    def node_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点名称。
        """
        return pulumi.get(self, "node_name")

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

    @property
    @pulumi.getter(name="nodeState")
    def node_state(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点状态。UNKNOWN：未知状态。CREATING：创建中。RUNNING：运行中。STOPPING：停止中。STOPPED：已停止。REBOOTING：重启中。DELETED：已删除。
        """
        return pulumi.get(self, "node_state")

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

    @property
    @pulumi.getter(name="privateIp")
    def private_ip(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        私有IP。
        """
        return pulumi.get(self, "private_ip")

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

    @property
    @pulumi.getter(name="publicIp")
    def public_ip(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        公网IP。
        """
        return pulumi.get(self, "public_ip")

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

    @property
    @pulumi.getter(name="readyTime")
    def ready_time(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        准备完毕时间。
        """
        return pulumi.get(self, "ready_time")

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

    @property
    @pulumi.getter(name="terminateTime")
    def terminate_time(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        集群终止时间。
        """
        return pulumi.get(self, "terminate_time")

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


if not MYPY:
    class NodeGroupSystemDiskArgsDict(TypedDict):
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        系统盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        volume_type: NotRequired[pulumi.Input[builtins.str]]
        """
        磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV。
        """
elif False:
    NodeGroupSystemDiskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NodeGroupSystemDiskArgs:
    def __init__(__self__, *,
                 size: Optional[pulumi.Input[builtins.int]] = None,
                 volume_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] size: 系统盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param pulumi.Input[builtins.str] volume_type: 磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV。
        """
        if size is not None:
            pulumi.set(__self__, "size", size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        系统盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        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="volumeType")
    def volume_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        磁盘类型。ESSD*PL0 ：极速型SSD*PL0。ESSD*PL1 ：极速型SSD*PL1。ESSD*PL2 ：极速型SSD*PL2。ESSD*PL3 ：极速型SSD*PL3。ESSD*FLEXPL ：极速型SSD*FlexPL。ULTRA*DISK ：高效云盘。PTSSD ：性能型SSD。SSD ：通用型SSD。EHDD ：高效云盘。ZENYA*SSD ：Zenya。LOCAL*HDD ：大数据型HDD。LOCAL*SSD ：本地SSD型。LOCAL*SSD*SRIOV ：本地SSD型SRIOV。
        """
        return pulumi.get(self, "volume_type")

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


