# 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
from . import outputs

__all__ = [
    'ClusterApplication',
    'ClusterApplicationExtra',
    'ClusterApplicationExtraApplicationComponentLayout',
    'ClusterApplicationExtraApplicationComponentLayoutEffectiveScope',
    'ClusterApplicationExtraApplicationConfig',
    'ClusterApplicationExtraApplicationConfigEffectiveScope',
    'ClusterBootstrapScript',
    'ClusterBootstrapScriptEffectiveScope',
    'ClusterChargePreConfig',
    'ClusterNodeAttribute',
    'ClusterNodeGroupAttribute',
    'ClusterNodeGroupAttributeDataDisk',
    'ClusterNodeGroupAttributeSystemDisk',
    'ClusterStateChangeReason',
    'ClusterTag',
    'NodeGroupApplicationLayout',
    'NodeGroupChargePreConfig',
    'NodeGroupDataDisk',
    'NodeGroupNode',
    'NodeGroupSystemDisk',
    'GetClusterApplicationResult',
    'GetClusterApplicationExtraResult',
    'GetClusterApplicationExtraApplicationComponentLayoutResult',
    'GetClusterApplicationExtraApplicationComponentLayoutEffectiveScopeResult',
    'GetClusterApplicationExtraApplicationConfigResult',
    'GetClusterApplicationExtraApplicationConfigEffectiveScopeResult',
    'GetClusterBootstrapScriptResult',
    'GetClusterBootstrapScriptEffectiveScopeResult',
    'GetClusterChargePreConfigResult',
    'GetClusterNodeAttributeResult',
    'GetClusterNodeGroupAttributeResult',
    'GetClusterNodeGroupAttributeDataDiskResult',
    'GetClusterNodeGroupAttributeSystemDiskResult',
    'GetClusterStateChangeReasonResult',
    'GetClusterTagResult',
    'GetNodeGroupApplicationLayoutResult',
    'GetNodeGroupChargePreConfigResult',
    'GetNodeGroupDataDiskResult',
    'GetNodeGroupNodeResult',
    'GetNodeGroupSystemDiskResult',
]

@pulumi.output_type
class ClusterApplication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "applicationConfigHome":
            suggest = "application_config_home"
        elif key == "applicationHome":
            suggest = "application_home"
        elif key == "applicationName":
            suggest = "application_name"
        elif key == "applicationState":
            suggest = "application_state"
        elif key == "applicationVersion":
            suggest = "application_version"
        elif key == "supportClient":
            suggest = "support_client"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterApplication. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterApplication.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterApplication.__key_warning(key)
        return super().get(key, default)

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

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

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

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

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

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

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

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


@pulumi.output_type
class ClusterApplicationExtra(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "applicationComponentLayouts":
            suggest = "application_component_layouts"
        elif key == "applicationConfigs":
            suggest = "application_configs"
        elif key == "applicationName":
            suggest = "application_name"
        elif key == "connectionId":
            suggest = "connection_id"
        elif key == "connectionType":
            suggest = "connection_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterApplicationExtra. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterApplicationExtra.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterApplicationExtra.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 application_component_layouts: Optional[Sequence['outputs.ClusterApplicationExtraApplicationComponentLayout']] = None,
                 application_configs: Optional[Sequence['outputs.ClusterApplicationExtraApplicationConfig']] = None,
                 application_name: Optional[builtins.str] = None,
                 connection_id: Optional[builtins.str] = None,
                 connection_type: Optional[builtins.str] = None):
        """
        :param builtins.str application_name: 应用名称。
        :param builtins.str connection_id: 元数据连接id。
        :param 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[Sequence['outputs.ClusterApplicationExtraApplicationComponentLayout']]:
        return pulumi.get(self, "application_component_layouts")

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

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

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

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


@pulumi.output_type
class ClusterApplicationExtraApplicationComponentLayout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "componentName":
            suggest = "component_name"
        elif key == "effectiveScope":
            suggest = "effective_scope"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterApplicationExtraApplicationComponentLayout. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterApplicationExtraApplicationComponentLayout.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterApplicationExtraApplicationComponentLayout.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 component_name: Optional[builtins.str] = None,
                 effective_scope: Optional['outputs.ClusterApplicationExtraApplicationComponentLayoutEffectiveScope'] = None):
        """
        :param builtins.str component_name: 组件名称。
        :param '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[builtins.str]:
        """
        组件名称。
        """
        return pulumi.get(self, "component_name")

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


@pulumi.output_type
class ClusterApplicationExtraApplicationComponentLayoutEffectiveScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "componentNames":
            suggest = "component_names"
        elif key == "effectiveType":
            suggest = "effective_type"
        elif key == "nodeGroupIds":
            suggest = "node_group_ids"
        elif key == "nodeGroupNames":
            suggest = "node_group_names"
        elif key == "nodeGroupTypes":
            suggest = "node_group_types"
        elif key == "nodeIds":
            suggest = "node_ids"
        elif key == "nodeNames":
            suggest = "node_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterApplicationExtraApplicationComponentLayoutEffectiveScope. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterApplicationExtraApplicationComponentLayoutEffectiveScope.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterApplicationExtraApplicationComponentLayoutEffectiveScope.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 component_names: Optional[Sequence[builtins.str]] = None,
                 effective_type: Optional[builtins.str] = None,
                 node_group_ids: Optional[Sequence[builtins.str]] = None,
                 node_group_names: Optional[Sequence[builtins.str]] = None,
                 node_group_types: Optional[Sequence[builtins.str]] = None,
                 node_ids: Optional[Sequence[builtins.str]] = None,
                 node_names: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] component_names: 组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        :param builtins.str effective_type: 生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        :param Sequence[builtins.str] node_group_ids: 节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        :param Sequence[builtins.str] node_group_names: 节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        :param Sequence[builtins.str] node_group_types: 节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        :param Sequence[builtins.str] node_ids: 节点ID列表，EffectiveType=NODE_ID时，必选。
        :param Sequence[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[Sequence[builtins.str]]:
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        return pulumi.get(self, "component_names")

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

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

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

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

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

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


@pulumi.output_type
class ClusterApplicationExtraApplicationConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "componentInstanceName":
            suggest = "component_instance_name"
        elif key == "componentName":
            suggest = "component_name"
        elif key == "configFileName":
            suggest = "config_file_name"
        elif key == "configItemKey":
            suggest = "config_item_key"
        elif key == "configItemValue":
            suggest = "config_item_value"
        elif key == "effectiveScope":
            suggest = "effective_scope"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterApplicationExtraApplicationConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterApplicationExtraApplicationConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterApplicationExtraApplicationConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 component_instance_name: Optional[builtins.str] = None,
                 component_name: Optional[builtins.str] = None,
                 config_file_name: Optional[builtins.str] = None,
                 config_item_key: Optional[builtins.str] = None,
                 config_item_value: Optional[builtins.str] = None,
                 deleted: Optional[builtins.bool] = None,
                 effective_scope: Optional['outputs.ClusterApplicationExtraApplicationConfigEffectiveScope'] = None):
        """
        :param builtins.str component_instance_name: 组件实例名称。
        :param builtins.str component_name: 组件名称。
        :param builtins.str config_file_name: 配置文件名。
        :param builtins.str config_item_key: 配置项名称。
        :param builtins.str config_item_value: 配置项值。
        :param builtins.bool deleted: 是否删除。
        :param '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[builtins.str]:
        """
        组件实例名称。
        """
        return pulumi.get(self, "component_instance_name")

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

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

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

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

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

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


@pulumi.output_type
class ClusterApplicationExtraApplicationConfigEffectiveScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "componentNames":
            suggest = "component_names"
        elif key == "effectiveType":
            suggest = "effective_type"
        elif key == "nodeGroupIds":
            suggest = "node_group_ids"
        elif key == "nodeGroupNames":
            suggest = "node_group_names"
        elif key == "nodeGroupTypes":
            suggest = "node_group_types"
        elif key == "nodeIds":
            suggest = "node_ids"
        elif key == "nodeNames":
            suggest = "node_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterApplicationExtraApplicationConfigEffectiveScope. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterApplicationExtraApplicationConfigEffectiveScope.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterApplicationExtraApplicationConfigEffectiveScope.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 component_names: Optional[Sequence[builtins.str]] = None,
                 effective_type: Optional[builtins.str] = None,
                 node_group_ids: Optional[Sequence[builtins.str]] = None,
                 node_group_names: Optional[Sequence[builtins.str]] = None,
                 node_group_types: Optional[Sequence[builtins.str]] = None,
                 node_ids: Optional[Sequence[builtins.str]] = None,
                 node_names: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] component_names: 组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        :param builtins.str effective_type: 生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        :param Sequence[builtins.str] node_group_ids: 节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        :param Sequence[builtins.str] node_group_names: 节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        :param Sequence[builtins.str] node_group_types: 节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        :param Sequence[builtins.str] node_ids: 节点ID列表，EffectiveType=NODE_ID时，必选。
        :param Sequence[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[Sequence[builtins.str]]:
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        return pulumi.get(self, "component_names")

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

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

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

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

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

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


@pulumi.output_type
class ClusterBootstrapScript(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "effectiveScope":
            suggest = "effective_scope"
        elif key == "executionFailStrategy":
            suggest = "execution_fail_strategy"
        elif key == "executionMoment":
            suggest = "execution_moment"
        elif key == "scriptArgs":
            suggest = "script_args"
        elif key == "scriptName":
            suggest = "script_name"
        elif key == "scriptPath":
            suggest = "script_path"
        elif key == "scriptType":
            suggest = "script_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterBootstrapScript. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterBootstrapScript.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterBootstrapScript.__key_warning(key)
        return super().get(key, default)

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

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

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

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

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

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

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

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


@pulumi.output_type
class ClusterBootstrapScriptEffectiveScope(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "componentNames":
            suggest = "component_names"
        elif key == "effectiveType":
            suggest = "effective_type"
        elif key == "nodeGroupIds":
            suggest = "node_group_ids"
        elif key == "nodeGroupNames":
            suggest = "node_group_names"
        elif key == "nodeGroupTypes":
            suggest = "node_group_types"
        elif key == "nodeIds":
            suggest = "node_ids"
        elif key == "nodeNames":
            suggest = "node_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterBootstrapScriptEffectiveScope. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterBootstrapScriptEffectiveScope.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterBootstrapScriptEffectiveScope.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 component_names: Optional[Sequence[builtins.str]] = None,
                 effective_type: Optional[builtins.str] = None,
                 node_group_ids: Optional[Sequence[builtins.str]] = None,
                 node_group_names: Optional[Sequence[builtins.str]] = None,
                 node_group_types: Optional[Sequence[builtins.str]] = None,
                 node_ids: Optional[Sequence[builtins.str]] = None,
                 node_names: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] component_names: 组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        :param builtins.str effective_type: 生效类型。CLUSTER，NODE*GROUP*NAME，NODE*GROUP*ID，NODE*GROUP*TYPE，NODE*NAME，NODE*ID，COMPONENT_NAME。
        :param Sequence[builtins.str] node_group_ids: 节点组ID列表，EffectiveType=NODE*GROUP*ID时，必选。
        :param Sequence[builtins.str] node_group_names: 节点组名称列表，EffectiveType=NODE*GROUP*NAME时，必选。
        :param Sequence[builtins.str] node_group_types: 节点组类型列表，EffectiveType=NODE*GROUP*TYPE时，必选。目前包括MASTER、CORE、TASK。
        :param Sequence[builtins.str] node_ids: 节点ID列表，EffectiveType=NODE_ID时，必选。
        :param Sequence[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[Sequence[builtins.str]]:
        """
        组件名列表，当EffectiveType=COMPONENT_NAME，必选。
        """
        return pulumi.get(self, "component_names")

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

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

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

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

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

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


@pulumi.output_type
class ClusterChargePreConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoRenew":
            suggest = "auto_renew"
        elif key == "autoRenewPeriod":
            suggest = "auto_renew_period"
        elif key == "autoRenewPeriodUnit":
            suggest = "auto_renew_period_unit"
        elif key == "chargePeriod":
            suggest = "charge_period"
        elif key == "chargePeriodUnit":
            suggest = "charge_period_unit"
        elif key == "chargeType":
            suggest = "charge_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterChargePreConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterChargePreConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterChargePreConfig.__key_warning(key)
        return super().get(key, default)

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

    @property
    @pulumi.getter(name="autoRenewPeriod")
    def auto_renew_period(self) -> Optional[builtins.int]:
        """
        自动续费触发时的续费时长，当AutoRenew=true时，默认值=1。
        """
        return pulumi.get(self, "auto_renew_period")

    @property
    @pulumi.getter(name="autoRenewPeriodUnit")
    def auto_renew_period_unit(self) -> Optional[builtins.str]:
        """
        自动续费触发时的续费时长单位，当AutoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "auto_renew_period_unit")

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

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

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


@pulumi.output_type
class ClusterNodeAttribute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ecsIamRole":
            suggest = "ecs_iam_role"
        elif key == "zoneId":
            suggest = "zone_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeAttribute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterNodeAttribute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterNodeAttribute.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ecs_iam_role: Optional[builtins.str] = None,
                 zone_id: Optional[builtins.str] = None):
        """
        :param builtins.str ecs_iam_role: ECS实例角色。
        :param 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[builtins.str]:
        """
        ECS实例角色。
        """
        return pulumi.get(self, "ecs_iam_role")

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


@pulumi.output_type
class ClusterNodeGroupAttribute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "chargeType":
            suggest = "charge_type"
        elif key == "dataDisks":
            suggest = "data_disks"
        elif key == "ecsInstanceTypes":
            suggest = "ecs_instance_types"
        elif key == "ecsKeyPairName":
            suggest = "ecs_key_pair_name"
        elif key == "ecsPassword":
            suggest = "ecs_password"
        elif key == "nodeCount":
            suggest = "node_count"
        elif key == "nodeGroupName":
            suggest = "node_group_name"
        elif key == "nodeGroupType":
            suggest = "node_group_type"
        elif key == "subnetIds":
            suggest = "subnet_ids"
        elif key == "systemDisk":
            suggest = "system_disk"
        elif key == "withPublicIp":
            suggest = "with_public_ip"
        elif key == "zoneId":
            suggest = "zone_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAttribute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterNodeGroupAttribute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterNodeGroupAttribute.__key_warning(key)
        return super().get(key, default)

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

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> Optional[builtins.str]:
        """
        节点组付费类型。为空时，复用集群的chargeType。Master、Core组必须复用集群维度的付费类型。当集群的chargeType为PRE时，task节点组的chargeType允许设置为POST；当集群的chargeType为POST时，节点组的chargeType默认为POST，节点组上的此参数设置无效。
        """
        return pulumi.get(self, "charge_type")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Optional[Sequence[builtins.str]]:
        """
        子网Id列表，目前只能传递一个参数，且各节点组的子网Id都是相同的。
        """
        return pulumi.get(self, "subnet_ids")

    @property
    @pulumi.getter(name="systemDisk")
    def system_disk(self) -> Optional['outputs.ClusterNodeGroupAttributeSystemDisk']:
        """
        系统盘配置。
        """
        return pulumi.get(self, "system_disk")

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

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


@pulumi.output_type
class ClusterNodeGroupAttributeDataDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAttributeDataDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterNodeGroupAttributeDataDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterNodeGroupAttributeDataDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 count: Optional[builtins.int] = None,
                 size: Optional[builtins.int] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.int count: 磁盘块数，默认值4，最大15，最小1。
        :param builtins.int size: 磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param 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[builtins.int]:
        """
        磁盘块数，默认值4，最大15，最小1。
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.int]:
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[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")


@pulumi.output_type
class ClusterNodeGroupAttributeSystemDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeGroupAttributeSystemDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterNodeGroupAttributeSystemDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterNodeGroupAttributeSystemDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 size: Optional[builtins.int] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.int size: 磁盘大小。
        :param 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[builtins.int]:
        """
        磁盘大小。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[builtins.str]:
        """
        磁盘类型。
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class ClusterStateChangeReason(dict):
    def __init__(__self__, *,
                 code: Optional[builtins.str] = None,
                 reason: Optional[builtins.str] = None):
        """
        :param builtins.str code: 状态更新码。
        :param 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[builtins.str]:
        """
        状态更新码。
        """
        return pulumi.get(self, "code")

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


@pulumi.output_type
class ClusterTag(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: 用户标签的标签键。
        :param 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[builtins.str]:
        """
        用户标签的标签键。
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class NodeGroupApplicationLayout(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "applicationName":
            suggest = "application_name"
        elif key == "layoutComponentNames":
            suggest = "layout_component_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupApplicationLayout. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupApplicationLayout.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupApplicationLayout.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 application_name: Optional[builtins.str] = None,
                 layout_component_names: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.str application_name: 应用名称。
        :param Sequence[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[builtins.str]:
        """
        应用名称。
        """
        return pulumi.get(self, "application_name")

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


@pulumi.output_type
class NodeGroupChargePreConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoRenew":
            suggest = "auto_renew"
        elif key == "autoRenewPeriod":
            suggest = "auto_renew_period"
        elif key == "autoRenewPeriodUnit":
            suggest = "auto_renew_period_unit"
        elif key == "chargePeriod":
            suggest = "charge_period"
        elif key == "chargePeriodUnit":
            suggest = "charge_period_unit"
        elif key == "chargeType":
            suggest = "charge_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupChargePreConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupChargePreConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupChargePreConfig.__key_warning(key)
        return super().get(key, default)

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

    @property
    @pulumi.getter(name="autoRenewPeriod")
    def auto_renew_period(self) -> Optional[builtins.int]:
        """
        自动续费触发时的续费时长，当autoRenew=true时，默认值=1。
        """
        return pulumi.get(self, "auto_renew_period")

    @property
    @pulumi.getter(name="autoRenewPeriodUnit")
    def auto_renew_period_unit(self) -> Optional[builtins.str]:
        """
        自动续费触发时的续费时长单位，当autoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "auto_renew_period_unit")

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

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

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


@pulumi.output_type
class NodeGroupDataDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupDataDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupDataDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupDataDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 count: Optional[builtins.int] = None,
                 size: Optional[builtins.int] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.int count: 磁盘块数，默认值4，最大15，最小1。
        :param builtins.int size: 磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param 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[builtins.int]:
        """
        磁盘块数，默认值4，最大15，最小1。
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter
    def size(self) -> Optional[builtins.int]:
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[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")


@pulumi.output_type
class NodeGroupNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createdTime":
            suggest = "created_time"
        elif key == "ecsInstanceType":
            suggest = "ecs_instance_type"
        elif key == "nodeFqdn":
            suggest = "node_fqdn"
        elif key == "nodeId":
            suggest = "node_id"
        elif key == "nodeName":
            suggest = "node_name"
        elif key == "nodeState":
            suggest = "node_state"
        elif key == "privateIp":
            suggest = "private_ip"
        elif key == "publicIp":
            suggest = "public_ip"
        elif key == "readyTime":
            suggest = "ready_time"
        elif key == "terminateTime":
            suggest = "terminate_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupNode. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupNode.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupNode.__key_warning(key)
        return super().get(key, default)

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class NodeGroupSystemDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeGroupSystemDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeGroupSystemDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeGroupSystemDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 size: Optional[builtins.int] = None,
                 volume_type: Optional[builtins.str] = None):
        """
        :param builtins.int size: 系统盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param 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[builtins.int]:
        """
        系统盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[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")


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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetClusterApplicationExtraResult(dict):
    def __init__(__self__, *,
                 application_component_layouts: Sequence['outputs.GetClusterApplicationExtraApplicationComponentLayoutResult'],
                 application_configs: Sequence['outputs.GetClusterApplicationExtraApplicationConfigResult'],
                 application_name: builtins.str,
                 connection_id: builtins.str,
                 connection_type: builtins.str):
        """
        :param Sequence['GetClusterApplicationExtraApplicationComponentLayoutArgs'] application_component_layouts: 服务组件的自定义部署拓扑列表。
        :param Sequence['GetClusterApplicationExtraApplicationConfigArgs'] application_configs: 服务的自定义配置参数列表。
        :param builtins.str application_name: 应用名称。
        :param builtins.str connection_id: 元数据连接id。
        :param builtins.str connection_type: 元数据连接类型。BUILT*IN*MYSQL：内置数据库。EXTERNAL*MYSQL：外置数据库。HIVE*METASTORE：HMS。
        """
        pulumi.set(__self__, "application_component_layouts", application_component_layouts)
        pulumi.set(__self__, "application_configs", application_configs)
        pulumi.set(__self__, "application_name", application_name)
        pulumi.set(__self__, "connection_id", connection_id)
        pulumi.set(__self__, "connection_type", connection_type)

    @property
    @pulumi.getter(name="applicationComponentLayouts")
    def application_component_layouts(self) -> Sequence['outputs.GetClusterApplicationExtraApplicationComponentLayoutResult']:
        """
        服务组件的自定义部署拓扑列表。
        """
        return pulumi.get(self, "application_component_layouts")

    @property
    @pulumi.getter(name="applicationConfigs")
    def application_configs(self) -> Sequence['outputs.GetClusterApplicationExtraApplicationConfigResult']:
        """
        服务的自定义配置参数列表。
        """
        return pulumi.get(self, "application_configs")

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

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

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


@pulumi.output_type
class GetClusterApplicationExtraApplicationComponentLayoutResult(dict):
    def __init__(__self__, *,
                 component_name: builtins.str,
                 effective_scope: 'outputs.GetClusterApplicationExtraApplicationComponentLayoutEffectiveScopeResult'):
        """
        :param builtins.str component_name: 组件名称。
        :param 'GetClusterApplicationExtraApplicationComponentLayoutEffectiveScopeArgs' effective_scope: 组件的布局范围。
        """
        pulumi.set(__self__, "component_name", component_name)
        pulumi.set(__self__, "effective_scope", effective_scope)

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

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


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

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

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

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

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

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

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

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


@pulumi.output_type
class GetClusterApplicationExtraApplicationConfigResult(dict):
    def __init__(__self__, *,
                 component_instance_name: builtins.str,
                 component_name: builtins.str,
                 config_file_name: builtins.str,
                 config_item_key: builtins.str,
                 config_item_value: builtins.str,
                 deleted: builtins.bool,
                 effective_scope: 'outputs.GetClusterApplicationExtraApplicationConfigEffectiveScopeResult'):
        """
        :param builtins.str component_instance_name: 组件实例名称。
        :param builtins.str component_name: 组件名称。
        :param builtins.str config_file_name: 配置文件名。
        :param builtins.str config_item_key: 配置项名称。
        :param builtins.str config_item_value: 配置项值。
        :param builtins.bool deleted: 是否删除。
        :param 'GetClusterApplicationExtraApplicationConfigEffectiveScopeArgs' effective_scope: 影响组件。
        """
        pulumi.set(__self__, "component_instance_name", component_instance_name)
        pulumi.set(__self__, "component_name", component_name)
        pulumi.set(__self__, "config_file_name", config_file_name)
        pulumi.set(__self__, "config_item_key", config_item_key)
        pulumi.set(__self__, "config_item_value", config_item_value)
        pulumi.set(__self__, "deleted", deleted)
        pulumi.set(__self__, "effective_scope", effective_scope)

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

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

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

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

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

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

    @property
    @pulumi.getter(name="effectiveScope")
    def effective_scope(self) -> 'outputs.GetClusterApplicationExtraApplicationConfigEffectiveScopeResult':
        """
        影响组件。
        """
        return pulumi.get(self, "effective_scope")


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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


@pulumi.output_type
class GetClusterChargePreConfigResult(dict):
    def __init__(__self__, *,
                 auto_renew: builtins.bool,
                 auto_renew_period: builtins.int,
                 auto_renew_period_unit: builtins.str,
                 charge_period: builtins.int,
                 charge_period_unit: builtins.str,
                 charge_type: builtins.str):
        """
        :param builtins.bool auto_renew: 是否开启自动续费。取值范围：true：开启。false：不开启。
        :param builtins.int auto_renew_period: 自动续费触发时的续费时长，当AutoRenew=true时，默认值=1。
        :param builtins.str auto_renew_period_unit: 自动续费触发时的续费时长单位，当AutoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        :param builtins.int charge_period: chargeType=PRE默认值=1，包月的购买时长单位。
        :param builtins.str charge_period_unit: chargeType=PRE时，默认值=Month，包月的购买时长单位，取值范围：Month：月。Year：年。
        :param builtins.str charge_type: 付费类型，取值范围：PRE，POST。
        """
        pulumi.set(__self__, "auto_renew", auto_renew)
        pulumi.set(__self__, "auto_renew_period", auto_renew_period)
        pulumi.set(__self__, "auto_renew_period_unit", auto_renew_period_unit)
        pulumi.set(__self__, "charge_period", charge_period)
        pulumi.set(__self__, "charge_period_unit", charge_period_unit)
        pulumi.set(__self__, "charge_type", charge_type)

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> builtins.bool:
        """
        是否开启自动续费。取值范围：true：开启。false：不开启。
        """
        return pulumi.get(self, "auto_renew")

    @property
    @pulumi.getter(name="autoRenewPeriod")
    def auto_renew_period(self) -> builtins.int:
        """
        自动续费触发时的续费时长，当AutoRenew=true时，默认值=1。
        """
        return pulumi.get(self, "auto_renew_period")

    @property
    @pulumi.getter(name="autoRenewPeriodUnit")
    def auto_renew_period_unit(self) -> builtins.str:
        """
        自动续费触发时的续费时长单位，当AutoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "auto_renew_period_unit")

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

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

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


@pulumi.output_type
class GetClusterNodeAttributeResult(dict):
    def __init__(__self__, *,
                 ecs_iam_role: builtins.str,
                 zone_id: builtins.str):
        """
        :param builtins.str ecs_iam_role: ECS实例角色。
        :param builtins.str zone_id: 可用区ID。
        """
        pulumi.set(__self__, "ecs_iam_role", ecs_iam_role)
        pulumi.set(__self__, "zone_id", zone_id)

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

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


@pulumi.output_type
class GetClusterNodeGroupAttributeResult(dict):
    def __init__(__self__, *,
                 bandwidth: builtins.int,
                 charge_type: builtins.str,
                 create_time: builtins.int,
                 data_disks: Sequence['outputs.GetClusterNodeGroupAttributeDataDiskResult'],
                 ecs_instance_types: Sequence[builtins.str],
                 ecs_key_pair_name: builtins.str,
                 ecs_password: builtins.str,
                 layout_component_names: Sequence[builtins.str],
                 node_count: builtins.int,
                 node_group_id: builtins.str,
                 node_group_name: builtins.str,
                 node_group_state: builtins.str,
                 node_group_type: builtins.str,
                 subnet_ids: Sequence[builtins.str],
                 system_disk: 'outputs.GetClusterNodeGroupAttributeSystemDiskResult',
                 with_public_ip: builtins.bool,
                 zone_id: builtins.str):
        """
        :param builtins.int bandwidth: 公网带宽。默认值 8M。后续如果用户侧调整了，emr侧需要同步该信息。
        :param builtins.str charge_type: 节点组付费类型。为空时，复用集群的chargeType。Master、Core组必须复用集群维度的付费类型。当集群的chargeType为PRE时，task节点组的chargeType允许设置为POST；当集群的chargeType为POST时，节点组的chargeType默认为POST，节点组上的此参数设置无效。
        :param builtins.int create_time: 节点组创建时间。
        :param Sequence['GetClusterNodeGroupAttributeDataDiskArgs'] data_disks: 数据盘配置。当前单个节点组内只支持同规格的数据盘。即List的长度限制为1。
        :param Sequence[builtins.str] ecs_instance_types: 节点组的ecs机型列表。当前只支持设置1个机型。即List的长度限制为1。
        :param builtins.str ecs_key_pair_name: ecs的密钥对名称。
        :param builtins.str ecs_password: Ecs root账号的密码。
        :param Sequence[builtins.str] layout_component_names: 部署的组件名称列表。
        :param builtins.int node_count: 节点组当前期望购买的节点数量。
        :param builtins.str node_group_id: 节点组ID。
        :param builtins.str node_group_name: 长度为1~128个字符，不能以 http:： 和 https:： 开头。可以包含中文、英文、数字、下划线（_）、或者短划线（-）。
        :param builtins.str node_group_state: 节点组状态。RUNNING,运行中。EXTENDING，扩容中。REDUCING，缩容中。DISK_EXTENDING，磁盘扩容中。MODIFYING，变配中
        :param builtins.str node_group_type: 节点组类型。
        :param Sequence[builtins.str] subnet_ids: 子网Id列表，目前只能传递一个参数，且各节点组的子网Id都是相同的。
        :param 'GetClusterNodeGroupAttributeSystemDiskArgs' system_disk: 系统盘配置。
        :param builtins.bool with_public_ip: 是否挂载公网ip。
        :param builtins.str zone_id: 可用区ID。
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "charge_type", charge_type)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "data_disks", data_disks)
        pulumi.set(__self__, "ecs_instance_types", ecs_instance_types)
        pulumi.set(__self__, "ecs_key_pair_name", ecs_key_pair_name)
        pulumi.set(__self__, "ecs_password", ecs_password)
        pulumi.set(__self__, "layout_component_names", layout_component_names)
        pulumi.set(__self__, "node_count", node_count)
        pulumi.set(__self__, "node_group_id", node_group_id)
        pulumi.set(__self__, "node_group_name", node_group_name)
        pulumi.set(__self__, "node_group_state", node_group_state)
        pulumi.set(__self__, "node_group_type", node_group_type)
        pulumi.set(__self__, "subnet_ids", subnet_ids)
        pulumi.set(__self__, "system_disk", system_disk)
        pulumi.set(__self__, "with_public_ip", with_public_ip)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter
    def bandwidth(self) -> builtins.int:
        """
        公网带宽。默认值 8M。后续如果用户侧调整了，emr侧需要同步该信息。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> builtins.str:
        """
        节点组付费类型。为空时，复用集群的chargeType。Master、Core组必须复用集群维度的付费类型。当集群的chargeType为PRE时，task节点组的chargeType允许设置为POST；当集群的chargeType为POST时，节点组的chargeType默认为POST，节点组上的此参数设置无效。
        """
        return pulumi.get(self, "charge_type")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> builtins.int:
        """
        节点组创建时间。
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter(name="dataDisks")
    def data_disks(self) -> Sequence['outputs.GetClusterNodeGroupAttributeDataDiskResult']:
        """
        数据盘配置。当前单个节点组内只支持同规格的数据盘。即List的长度限制为1。
        """
        return pulumi.get(self, "data_disks")

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

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

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

    @property
    @pulumi.getter(name="layoutComponentNames")
    def layout_component_names(self) -> Sequence[builtins.str]:
        """
        部署的组件名称列表。
        """
        return pulumi.get(self, "layout_component_names")

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

    @property
    @pulumi.getter(name="nodeGroupId")
    def node_group_id(self) -> builtins.str:
        """
        节点组ID。
        """
        return pulumi.get(self, "node_group_id")

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

    @property
    @pulumi.getter(name="nodeGroupState")
    def node_group_state(self) -> builtins.str:
        """
        节点组状态。RUNNING,运行中。EXTENDING，扩容中。REDUCING，缩容中。DISK_EXTENDING，磁盘扩容中。MODIFYING，变配中
        """
        return pulumi.get(self, "node_group_state")

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

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Sequence[builtins.str]:
        """
        子网Id列表，目前只能传递一个参数，且各节点组的子网Id都是相同的。
        """
        return pulumi.get(self, "subnet_ids")

    @property
    @pulumi.getter(name="systemDisk")
    def system_disk(self) -> 'outputs.GetClusterNodeGroupAttributeSystemDiskResult':
        """
        系统盘配置。
        """
        return pulumi.get(self, "system_disk")

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

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


@pulumi.output_type
class GetClusterNodeGroupAttributeDataDiskResult(dict):
    def __init__(__self__, *,
                 count: builtins.int,
                 size: builtins.int,
                 volume_type: builtins.str):
        """
        :param builtins.int count: 磁盘块数，默认值4，最大15，最小1。
        :param builtins.int size: 磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param 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
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "volume_type", volume_type)

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

    @property
    @pulumi.getter
    def size(self) -> builtins.int:
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> 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")


@pulumi.output_type
class GetClusterNodeGroupAttributeSystemDiskResult(dict):
    def __init__(__self__, *,
                 size: builtins.int,
                 volume_type: builtins.str):
        """
        :param builtins.int size: 磁盘大小。
        :param builtins.str volume_type: 磁盘类型。
        """
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def size(self) -> builtins.int:
        """
        磁盘大小。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> builtins.str:
        """
        磁盘类型。
        """
        return pulumi.get(self, "volume_type")


@pulumi.output_type
class GetClusterStateChangeReasonResult(dict):
    def __init__(__self__, *,
                 code: builtins.str,
                 reason: builtins.str):
        """
        :param builtins.str code: 状态更新码。
        :param builtins.str reason: 状态更新原因。
        """
        pulumi.set(__self__, "code", code)
        pulumi.set(__self__, "reason", reason)

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

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


@pulumi.output_type
class GetClusterTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 用户标签的标签键。
        :param builtins.str value: 用户标签的标签值。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        用户标签的标签键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        用户标签的标签值。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetNodeGroupApplicationLayoutResult(dict):
    def __init__(__self__, *,
                 application_name: builtins.str,
                 layout_component_names: Sequence[builtins.str]):
        """
        :param builtins.str application_name: 应用名称。
        :param Sequence[builtins.str] layout_component_names: 组件的自定义配置参数列表。
        """
        pulumi.set(__self__, "application_name", application_name)
        pulumi.set(__self__, "layout_component_names", layout_component_names)

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

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


@pulumi.output_type
class GetNodeGroupChargePreConfigResult(dict):
    def __init__(__self__, *,
                 auto_renew: builtins.bool,
                 auto_renew_period: builtins.int,
                 auto_renew_period_unit: builtins.str,
                 charge_period: builtins.int,
                 charge_period_unit: builtins.str,
                 charge_type: builtins.str):
        """
        :param builtins.bool auto_renew: 是否开启自动续费。
        :param builtins.int auto_renew_period: 自动续费触发时的续费时长，当autoRenew=true时，默认值=1。
        :param builtins.str auto_renew_period_unit: 自动续费触发时的续费时长单位，当autoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        :param builtins.int charge_period: chargeType=PRE默认值=1，包月的购买时长单位。
        :param builtins.str charge_period_unit: chargeType=PRE时，默认值=Month，包月的购买时长单位。取值范围：Month：月。Year：年。
        :param builtins.str charge_type: 付费类型，枚举值：POST，PRE。
        """
        pulumi.set(__self__, "auto_renew", auto_renew)
        pulumi.set(__self__, "auto_renew_period", auto_renew_period)
        pulumi.set(__self__, "auto_renew_period_unit", auto_renew_period_unit)
        pulumi.set(__self__, "charge_period", charge_period)
        pulumi.set(__self__, "charge_period_unit", charge_period_unit)
        pulumi.set(__self__, "charge_type", charge_type)

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> builtins.bool:
        """
        是否开启自动续费。
        """
        return pulumi.get(self, "auto_renew")

    @property
    @pulumi.getter(name="autoRenewPeriod")
    def auto_renew_period(self) -> builtins.int:
        """
        自动续费触发时的续费时长，当autoRenew=true时，默认值=1。
        """
        return pulumi.get(self, "auto_renew_period")

    @property
    @pulumi.getter(name="autoRenewPeriodUnit")
    def auto_renew_period_unit(self) -> builtins.str:
        """
        自动续费触发时的续费时长单位，当autoRenew=true时，默认值=Month。取值范围：Month：月。Year：年。
        """
        return pulumi.get(self, "auto_renew_period_unit")

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

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

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


@pulumi.output_type
class GetNodeGroupDataDiskResult(dict):
    def __init__(__self__, *,
                 count: builtins.int,
                 size: builtins.int,
                 volume_type: builtins.str):
        """
        :param builtins.int count: 磁盘块数，默认值4，最大15，最小1。
        :param builtins.int size: 磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param 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。
        """
        pulumi.set(__self__, "count", count)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "volume_type", volume_type)

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

    @property
    @pulumi.getter
    def size(self) -> builtins.int:
        """
        磁盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> 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")


@pulumi.output_type
class GetNodeGroupNodeResult(dict):
    def __init__(__self__, *,
                 created_time: builtins.int,
                 ecs_instance_type: builtins.str,
                 node_fqdn: builtins.str,
                 node_id: builtins.str,
                 node_name: builtins.str,
                 node_state: builtins.str,
                 private_ip: builtins.str,
                 public_ip: builtins.str,
                 ready_time: builtins.int,
                 terminate_time: builtins.int):
        """
        :param builtins.int created_time: 节点创建时间。
        :param builtins.str ecs_instance_type: ecs实例规格。
        :param builtins.str node_fqdn: 节点FQDN。
        :param builtins.str node_id: 节点ID。
        :param builtins.str node_name: 节点名称。
        :param builtins.str node_state: 节点状态。UNKNOWN：未知状态。CREATING：创建中。RUNNING：运行中。STOPPING：停止中。STOPPED：已停止。REBOOTING：重启中。DELETED：已删除。
        :param builtins.str private_ip: 私有IP。
        :param builtins.str public_ip: 公网IP。
        :param builtins.int ready_time: 准备完毕时间。
        :param builtins.int terminate_time: 集群终止时间。
        """
        pulumi.set(__self__, "created_time", created_time)
        pulumi.set(__self__, "ecs_instance_type", ecs_instance_type)
        pulumi.set(__self__, "node_fqdn", node_fqdn)
        pulumi.set(__self__, "node_id", node_id)
        pulumi.set(__self__, "node_name", node_name)
        pulumi.set(__self__, "node_state", node_state)
        pulumi.set(__self__, "private_ip", private_ip)
        pulumi.set(__self__, "public_ip", public_ip)
        pulumi.set(__self__, "ready_time", ready_time)
        pulumi.set(__self__, "terminate_time", terminate_time)

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetNodeGroupSystemDiskResult(dict):
    def __init__(__self__, *,
                 size: builtins.int,
                 volume_type: builtins.str):
        """
        :param builtins.int size: 系统盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        :param 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。
        """
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter
    def size(self) -> builtins.int:
        """
        系统盘大小，默认值80GB，最小60GB，最大2048GB，单位GB。
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> 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")


