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

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'InstanceInstanceConfigurationArgs',
    'InstanceInstanceConfigurationArgsDict',
    'InstanceInstanceConfigurationColdNodeResourceSpecArgs',
    'InstanceInstanceConfigurationColdNodeResourceSpecArgsDict',
    'InstanceInstanceConfigurationColdNodeStorageSpecArgs',
    'InstanceInstanceConfigurationColdNodeStorageSpecArgsDict',
    'InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgs',
    'InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgsDict',
    'InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgs',
    'InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgsDict',
    'InstanceInstanceConfigurationHotNodeResourceSpecArgs',
    'InstanceInstanceConfigurationHotNodeResourceSpecArgsDict',
    'InstanceInstanceConfigurationHotNodeStorageSpecArgs',
    'InstanceInstanceConfigurationHotNodeStorageSpecArgsDict',
    'InstanceInstanceConfigurationKibanaNodeResourceSpecArgs',
    'InstanceInstanceConfigurationKibanaNodeResourceSpecArgsDict',
    'InstanceInstanceConfigurationMasterNodeResourceSpecArgs',
    'InstanceInstanceConfigurationMasterNodeResourceSpecArgsDict',
    'InstanceInstanceConfigurationMasterNodeStorageSpecArgs',
    'InstanceInstanceConfigurationMasterNodeStorageSpecArgsDict',
    'InstanceInstanceConfigurationNetworkSpecArgs',
    'InstanceInstanceConfigurationNetworkSpecArgsDict',
    'InstanceInstanceConfigurationNodeSpecsAssignArgs',
    'InstanceInstanceConfigurationNodeSpecsAssignArgsDict',
    'InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgs',
    'InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgsDict',
    'InstanceInstanceConfigurationSubnetArgs',
    'InstanceInstanceConfigurationSubnetArgsDict',
    'InstanceInstanceConfigurationTagArgs',
    'InstanceInstanceConfigurationTagArgsDict',
    'InstanceInstanceConfigurationVpcArgs',
    'InstanceInstanceConfigurationVpcArgsDict',
    'InstanceInstanceConfigurationWarmNodeResourceSpecArgs',
    'InstanceInstanceConfigurationWarmNodeResourceSpecArgsDict',
    'InstanceInstanceConfigurationWarmNodeStorageSpecArgs',
    'InstanceInstanceConfigurationWarmNodeStorageSpecArgsDict',
    'InstanceKibanaConfigArgs',
    'InstanceKibanaConfigArgsDict',
    'InstanceSubInstanceArgs',
    'InstanceSubInstanceArgsDict',
    'InstanceTransferInfoArgs',
    'InstanceTransferInfoArgsDict',
    'InstanceTransferInfoReduceSpecConfigArgs',
    'InstanceTransferInfoReduceSpecConfigArgsDict',
]

MYPY = False

if not MYPY:
    class InstanceInstanceConfigurationArgsDict(TypedDict):
        admin_password: NotRequired[pulumi.Input[builtins.str]]
        """
        管理员密码。
        """
        admin_user_name: NotRequired[pulumi.Input[builtins.str]]
        """
        管理员用户名。
        """
        auto_renew: NotRequired[pulumi.Input[builtins.bool]]
        """
        包年包月实例是否配置自动续费。true：自动续费，系统会在每次到期前自动为实例续费。false：未开启自动续费，需要在实例到期前进行手动续费。如需了解更多，请参见实例续费。
        """
        charge_type: NotRequired[pulumi.Input[builtins.str]]
        """
        实例计费类型。PostPaid：按量计费。PrePaid：包年包月。
        """
        cold_node_number: NotRequired[pulumi.Input[builtins.int]]
        """
        冷节点数量。
        """
        cold_node_resource_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationColdNodeResourceSpecArgsDict']]
        """
        冷节点的节点规格配置详情。
        """
        cold_node_storage_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationColdNodeStorageSpecArgsDict']]
        """
        冷节点的存储规格配置详情。
        """
        configuration_code: NotRequired[pulumi.Input[builtins.str]]
        """
        计费配置码，可以通过调用DescribeNodeAvailableSpecs接口获得。
        """
        coordinator_node_number: NotRequired[pulumi.Input[builtins.int]]
        """
        协调节点数量。
        """
        coordinator_node_resource_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgsDict']]
        """
        协调节点的节点规格配置详情。
        """
        coordinator_node_storage_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgsDict']]
        """
        协调节点的存储规格配置详情。
        """
        deletion_protection: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启实例删除保护功能，取值说明如下：true：开启实例删除保护。false：关闭实例删除保护。说明开启实例删除保护后，您将无法通过控制台或者 API 删除实例。
        """
        enable_https: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否启用 HTTPS 访问协议。true：启用 HTTPS 访问。false：不启用 HTTPS，使用 HTTP 访问。说明如果选择使用 HTTP 访问，将无需安全认证即可访问，并使用 HTTP 明文传输数据。您需要确保访问环境的安全性，且不要将访问接口暴露在公网环境上。实例创建完成后，支持根据业务需求修改传输协议。相关文档，请参见切换实例传输协议。
        """
        enable_pure_master: NotRequired[pulumi.Input[builtins.bool]]
        """
        Master 节点是否独立。true：Master 节点独立。false：Master 节点与数据节点重合，即使用 Hot 声明。
        """
        hot_node_number: NotRequired[pulumi.Input[builtins.int]]
        """
        数据节点数量。
        """
        hot_node_resource_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationHotNodeResourceSpecArgsDict']]
        """
        数据节点的节点规格配置详情。
        """
        hot_node_storage_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationHotNodeStorageSpecArgsDict']]
        """
        数据节点的存储规格配置详情。
        """
        instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        自定义设置实例名称。只能包含中文、字母、数字、短横线（-）和下划线（_），开头和结尾不能是数字和短横线（-）。长度在 1～128 个字符内。
        """
        kibana_node_number: NotRequired[pulumi.Input[builtins.int]]
        """
        kibana 节点数量。
        """
        kibana_node_resource_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationKibanaNodeResourceSpecArgsDict']]
        """
        Kibana 节点的节点规格配置详情。
        """
        master_node_number: NotRequired[pulumi.Input[builtins.int]]
        """
        master 节点数量。
        """
        master_node_resource_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationMasterNodeResourceSpecArgsDict']]
        """
        Master 节点的节点规格配置详情。
        """
        master_node_storage_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationMasterNodeStorageSpecArgsDict']]
        """
        Master 节点的存储规格配置详情。
        """
        network_specs: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceInstanceConfigurationNetworkSpecArgsDict']]]]
        node_specs_assigns: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceInstanceConfigurationNodeSpecsAssignArgsDict']]]]
        period: NotRequired[pulumi.Input[builtins.int]]
        """
        包年包月实例的购买时长，单位：月。
        """
        project_name: NotRequired[pulumi.Input[builtins.str]]
        """
        按需设置云搜索实例所属的项目，有利于云资源的分组管理。项目是提供的一种资源管理方式，有利于维护资源独立、数据安全；同时可从项目维度查看资源消费账单，便于计算云资源使用成本。如需了解更多信息，请参见项目概述
        """
        region_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例所在区域。
        """
        subnet: NotRequired[pulumi.Input['InstanceInstanceConfigurationSubnetArgsDict']]
        """
        设置实例的子网信息。说明设置的子网必须是主可用区中的子网。
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceInstanceConfigurationTagArgsDict']]]]
        version: NotRequired[pulumi.Input[builtins.str]]
        """
        API的版本，取值：2023-01-01。
        """
        vpc: NotRequired[pulumi.Input['InstanceInstanceConfigurationVpcArgsDict']]
        """
        设置实例的私有网络 VPC 信息。
        """
        warm_node_number: NotRequired[pulumi.Input[builtins.int]]
        """
        温节点数量。
        """
        warm_node_resource_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationWarmNodeResourceSpecArgsDict']]
        """
        温节点的节点规格配置详情。
        """
        warm_node_storage_spec: NotRequired[pulumi.Input['InstanceInstanceConfigurationWarmNodeStorageSpecArgsDict']]
        """
        温节点的存储规格配置详情。
        """
        zone_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例所在可用区。说明如果是多可用区部署，则填写多个 ZoneId，使用英文逗号分隔，如cn-beijing-a,cn-beijing-c。最左侧的 ZoneId 为主可用区，其余为备可用区。
        """
        zone_number: NotRequired[pulumi.Input[builtins.int]]
        """
        实例的可用区数量。
        """
elif False:
    InstanceInstanceConfigurationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationArgs:
    def __init__(__self__, *,
                 admin_password: Optional[pulumi.Input[builtins.str]] = None,
                 admin_user_name: Optional[pulumi.Input[builtins.str]] = None,
                 auto_renew: Optional[pulumi.Input[builtins.bool]] = None,
                 charge_type: Optional[pulumi.Input[builtins.str]] = None,
                 cold_node_number: Optional[pulumi.Input[builtins.int]] = None,
                 cold_node_resource_spec: Optional[pulumi.Input['InstanceInstanceConfigurationColdNodeResourceSpecArgs']] = None,
                 cold_node_storage_spec: Optional[pulumi.Input['InstanceInstanceConfigurationColdNodeStorageSpecArgs']] = None,
                 configuration_code: Optional[pulumi.Input[builtins.str]] = None,
                 coordinator_node_number: Optional[pulumi.Input[builtins.int]] = None,
                 coordinator_node_resource_spec: Optional[pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgs']] = None,
                 coordinator_node_storage_spec: Optional[pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgs']] = None,
                 deletion_protection: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_https: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_pure_master: Optional[pulumi.Input[builtins.bool]] = None,
                 hot_node_number: Optional[pulumi.Input[builtins.int]] = None,
                 hot_node_resource_spec: Optional[pulumi.Input['InstanceInstanceConfigurationHotNodeResourceSpecArgs']] = None,
                 hot_node_storage_spec: Optional[pulumi.Input['InstanceInstanceConfigurationHotNodeStorageSpecArgs']] = None,
                 instance_name: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_node_number: Optional[pulumi.Input[builtins.int]] = None,
                 kibana_node_resource_spec: Optional[pulumi.Input['InstanceInstanceConfigurationKibanaNodeResourceSpecArgs']] = None,
                 master_node_number: Optional[pulumi.Input[builtins.int]] = None,
                 master_node_resource_spec: Optional[pulumi.Input['InstanceInstanceConfigurationMasterNodeResourceSpecArgs']] = None,
                 master_node_storage_spec: Optional[pulumi.Input['InstanceInstanceConfigurationMasterNodeStorageSpecArgs']] = None,
                 network_specs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInstanceConfigurationNetworkSpecArgs']]]] = None,
                 node_specs_assigns: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInstanceConfigurationNodeSpecsAssignArgs']]]] = None,
                 period: Optional[pulumi.Input[builtins.int]] = None,
                 project_name: Optional[pulumi.Input[builtins.str]] = None,
                 region_id: Optional[pulumi.Input[builtins.str]] = None,
                 subnet: Optional[pulumi.Input['InstanceInstanceConfigurationSubnetArgs']] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceInstanceConfigurationTagArgs']]]] = None,
                 version: Optional[pulumi.Input[builtins.str]] = None,
                 vpc: Optional[pulumi.Input['InstanceInstanceConfigurationVpcArgs']] = None,
                 warm_node_number: Optional[pulumi.Input[builtins.int]] = None,
                 warm_node_resource_spec: Optional[pulumi.Input['InstanceInstanceConfigurationWarmNodeResourceSpecArgs']] = None,
                 warm_node_storage_spec: Optional[pulumi.Input['InstanceInstanceConfigurationWarmNodeStorageSpecArgs']] = None,
                 zone_id: Optional[pulumi.Input[builtins.str]] = None,
                 zone_number: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] admin_password: 管理员密码。
        :param pulumi.Input[builtins.str] admin_user_name: 管理员用户名。
        :param pulumi.Input[builtins.bool] auto_renew: 包年包月实例是否配置自动续费。true：自动续费，系统会在每次到期前自动为实例续费。false：未开启自动续费，需要在实例到期前进行手动续费。如需了解更多，请参见实例续费。
        :param pulumi.Input[builtins.str] charge_type: 实例计费类型。PostPaid：按量计费。PrePaid：包年包月。
        :param pulumi.Input[builtins.int] cold_node_number: 冷节点数量。
        :param pulumi.Input['InstanceInstanceConfigurationColdNodeResourceSpecArgs'] cold_node_resource_spec: 冷节点的节点规格配置详情。
        :param pulumi.Input['InstanceInstanceConfigurationColdNodeStorageSpecArgs'] cold_node_storage_spec: 冷节点的存储规格配置详情。
        :param pulumi.Input[builtins.str] configuration_code: 计费配置码，可以通过调用DescribeNodeAvailableSpecs接口获得。
        :param pulumi.Input[builtins.int] coordinator_node_number: 协调节点数量。
        :param pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgs'] coordinator_node_resource_spec: 协调节点的节点规格配置详情。
        :param pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgs'] coordinator_node_storage_spec: 协调节点的存储规格配置详情。
        :param pulumi.Input[builtins.bool] deletion_protection: 是否开启实例删除保护功能，取值说明如下：true：开启实例删除保护。false：关闭实例删除保护。说明开启实例删除保护后，您将无法通过控制台或者 API 删除实例。
        :param pulumi.Input[builtins.bool] enable_https: 是否启用 HTTPS 访问协议。true：启用 HTTPS 访问。false：不启用 HTTPS，使用 HTTP 访问。说明如果选择使用 HTTP 访问，将无需安全认证即可访问，并使用 HTTP 明文传输数据。您需要确保访问环境的安全性，且不要将访问接口暴露在公网环境上。实例创建完成后，支持根据业务需求修改传输协议。相关文档，请参见切换实例传输协议。
        :param pulumi.Input[builtins.bool] enable_pure_master: Master 节点是否独立。true：Master 节点独立。false：Master 节点与数据节点重合，即使用 Hot 声明。
        :param pulumi.Input[builtins.int] hot_node_number: 数据节点数量。
        :param pulumi.Input['InstanceInstanceConfigurationHotNodeResourceSpecArgs'] hot_node_resource_spec: 数据节点的节点规格配置详情。
        :param pulumi.Input['InstanceInstanceConfigurationHotNodeStorageSpecArgs'] hot_node_storage_spec: 数据节点的存储规格配置详情。
        :param pulumi.Input[builtins.str] instance_name: 自定义设置实例名称。只能包含中文、字母、数字、短横线（-）和下划线（_），开头和结尾不能是数字和短横线（-）。长度在 1～128 个字符内。
        :param pulumi.Input[builtins.int] kibana_node_number: kibana 节点数量。
        :param pulumi.Input['InstanceInstanceConfigurationKibanaNodeResourceSpecArgs'] kibana_node_resource_spec: Kibana 节点的节点规格配置详情。
        :param pulumi.Input[builtins.int] master_node_number: master 节点数量。
        :param pulumi.Input['InstanceInstanceConfigurationMasterNodeResourceSpecArgs'] master_node_resource_spec: Master 节点的节点规格配置详情。
        :param pulumi.Input['InstanceInstanceConfigurationMasterNodeStorageSpecArgs'] master_node_storage_spec: Master 节点的存储规格配置详情。
        :param pulumi.Input[builtins.int] period: 包年包月实例的购买时长，单位：月。
        :param pulumi.Input[builtins.str] project_name: 按需设置云搜索实例所属的项目，有利于云资源的分组管理。项目是提供的一种资源管理方式，有利于维护资源独立、数据安全；同时可从项目维度查看资源消费账单，便于计算云资源使用成本。如需了解更多信息，请参见项目概述
        :param pulumi.Input[builtins.str] region_id: 实例所在区域。
        :param pulumi.Input['InstanceInstanceConfigurationSubnetArgs'] subnet: 设置实例的子网信息。说明设置的子网必须是主可用区中的子网。
        :param pulumi.Input[builtins.str] version: API的版本，取值：2023-01-01。
        :param pulumi.Input['InstanceInstanceConfigurationVpcArgs'] vpc: 设置实例的私有网络 VPC 信息。
        :param pulumi.Input[builtins.int] warm_node_number: 温节点数量。
        :param pulumi.Input['InstanceInstanceConfigurationWarmNodeResourceSpecArgs'] warm_node_resource_spec: 温节点的节点规格配置详情。
        :param pulumi.Input['InstanceInstanceConfigurationWarmNodeStorageSpecArgs'] warm_node_storage_spec: 温节点的存储规格配置详情。
        :param pulumi.Input[builtins.str] zone_id: 实例所在可用区。说明如果是多可用区部署，则填写多个 ZoneId，使用英文逗号分隔，如cn-beijing-a,cn-beijing-c。最左侧的 ZoneId 为主可用区，其余为备可用区。
        :param pulumi.Input[builtins.int] zone_number: 实例的可用区数量。
        """
        if admin_password is not None:
            pulumi.set(__self__, "admin_password", admin_password)
        if admin_user_name is not None:
            pulumi.set(__self__, "admin_user_name", admin_user_name)
        if auto_renew is not None:
            pulumi.set(__self__, "auto_renew", auto_renew)
        if charge_type is not None:
            pulumi.set(__self__, "charge_type", charge_type)
        if cold_node_number is not None:
            pulumi.set(__self__, "cold_node_number", cold_node_number)
        if cold_node_resource_spec is not None:
            pulumi.set(__self__, "cold_node_resource_spec", cold_node_resource_spec)
        if cold_node_storage_spec is not None:
            pulumi.set(__self__, "cold_node_storage_spec", cold_node_storage_spec)
        if configuration_code is not None:
            pulumi.set(__self__, "configuration_code", configuration_code)
        if coordinator_node_number is not None:
            pulumi.set(__self__, "coordinator_node_number", coordinator_node_number)
        if coordinator_node_resource_spec is not None:
            pulumi.set(__self__, "coordinator_node_resource_spec", coordinator_node_resource_spec)
        if coordinator_node_storage_spec is not None:
            pulumi.set(__self__, "coordinator_node_storage_spec", coordinator_node_storage_spec)
        if deletion_protection is not None:
            pulumi.set(__self__, "deletion_protection", deletion_protection)
        if enable_https is not None:
            pulumi.set(__self__, "enable_https", enable_https)
        if enable_pure_master is not None:
            pulumi.set(__self__, "enable_pure_master", enable_pure_master)
        if hot_node_number is not None:
            pulumi.set(__self__, "hot_node_number", hot_node_number)
        if hot_node_resource_spec is not None:
            pulumi.set(__self__, "hot_node_resource_spec", hot_node_resource_spec)
        if hot_node_storage_spec is not None:
            pulumi.set(__self__, "hot_node_storage_spec", hot_node_storage_spec)
        if instance_name is not None:
            pulumi.set(__self__, "instance_name", instance_name)
        if kibana_node_number is not None:
            pulumi.set(__self__, "kibana_node_number", kibana_node_number)
        if kibana_node_resource_spec is not None:
            pulumi.set(__self__, "kibana_node_resource_spec", kibana_node_resource_spec)
        if master_node_number is not None:
            pulumi.set(__self__, "master_node_number", master_node_number)
        if master_node_resource_spec is not None:
            pulumi.set(__self__, "master_node_resource_spec", master_node_resource_spec)
        if master_node_storage_spec is not None:
            pulumi.set(__self__, "master_node_storage_spec", master_node_storage_spec)
        if network_specs is not None:
            pulumi.set(__self__, "network_specs", network_specs)
        if node_specs_assigns is not None:
            pulumi.set(__self__, "node_specs_assigns", node_specs_assigns)
        if period is not None:
            pulumi.set(__self__, "period", period)
        if project_name is not None:
            pulumi.set(__self__, "project_name", project_name)
        if region_id is not None:
            pulumi.set(__self__, "region_id", region_id)
        if subnet is not None:
            pulumi.set(__self__, "subnet", subnet)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if version is not None:
            pulumi.set(__self__, "version", version)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)
        if warm_node_number is not None:
            pulumi.set(__self__, "warm_node_number", warm_node_number)
        if warm_node_resource_spec is not None:
            pulumi.set(__self__, "warm_node_resource_spec", warm_node_resource_spec)
        if warm_node_storage_spec is not None:
            pulumi.set(__self__, "warm_node_storage_spec", warm_node_storage_spec)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)
        if zone_number is not None:
            pulumi.set(__self__, "zone_number", zone_number)

    @property
    @pulumi.getter(name="adminPassword")
    def admin_password(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        管理员密码。
        """
        return pulumi.get(self, "admin_password")

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

    @property
    @pulumi.getter(name="adminUserName")
    def admin_user_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        管理员用户名。
        """
        return pulumi.get(self, "admin_user_name")

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

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        包年包月实例是否配置自动续费。true：自动续费，系统会在每次到期前自动为实例续费。false：未开启自动续费，需要在实例到期前进行手动续费。如需了解更多，请参见实例续费。
        """
        return pulumi.get(self, "auto_renew")

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

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例计费类型。PostPaid：按量计费。PrePaid：包年包月。
        """
        return pulumi.get(self, "charge_type")

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

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

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

    @property
    @pulumi.getter(name="coldNodeResourceSpec")
    def cold_node_resource_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationColdNodeResourceSpecArgs']]:
        """
        冷节点的节点规格配置详情。
        """
        return pulumi.get(self, "cold_node_resource_spec")

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

    @property
    @pulumi.getter(name="coldNodeStorageSpec")
    def cold_node_storage_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationColdNodeStorageSpecArgs']]:
        """
        冷节点的存储规格配置详情。
        """
        return pulumi.get(self, "cold_node_storage_spec")

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

    @property
    @pulumi.getter(name="configurationCode")
    def configuration_code(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        计费配置码，可以通过调用DescribeNodeAvailableSpecs接口获得。
        """
        return pulumi.get(self, "configuration_code")

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

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

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

    @property
    @pulumi.getter(name="coordinatorNodeResourceSpec")
    def coordinator_node_resource_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgs']]:
        """
        协调节点的节点规格配置详情。
        """
        return pulumi.get(self, "coordinator_node_resource_spec")

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

    @property
    @pulumi.getter(name="coordinatorNodeStorageSpec")
    def coordinator_node_storage_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgs']]:
        """
        协调节点的存储规格配置详情。
        """
        return pulumi.get(self, "coordinator_node_storage_spec")

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

    @property
    @pulumi.getter(name="deletionProtection")
    def deletion_protection(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启实例删除保护功能，取值说明如下：true：开启实例删除保护。false：关闭实例删除保护。说明开启实例删除保护后，您将无法通过控制台或者 API 删除实例。
        """
        return pulumi.get(self, "deletion_protection")

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

    @property
    @pulumi.getter(name="enableHttps")
    def enable_https(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否启用 HTTPS 访问协议。true：启用 HTTPS 访问。false：不启用 HTTPS，使用 HTTP 访问。说明如果选择使用 HTTP 访问，将无需安全认证即可访问，并使用 HTTP 明文传输数据。您需要确保访问环境的安全性，且不要将访问接口暴露在公网环境上。实例创建完成后，支持根据业务需求修改传输协议。相关文档，请参见切换实例传输协议。
        """
        return pulumi.get(self, "enable_https")

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

    @property
    @pulumi.getter(name="enablePureMaster")
    def enable_pure_master(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Master 节点是否独立。true：Master 节点独立。false：Master 节点与数据节点重合，即使用 Hot 声明。
        """
        return pulumi.get(self, "enable_pure_master")

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

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

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

    @property
    @pulumi.getter(name="hotNodeResourceSpec")
    def hot_node_resource_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationHotNodeResourceSpecArgs']]:
        """
        数据节点的节点规格配置详情。
        """
        return pulumi.get(self, "hot_node_resource_spec")

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

    @property
    @pulumi.getter(name="hotNodeStorageSpec")
    def hot_node_storage_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationHotNodeStorageSpecArgs']]:
        """
        数据节点的存储规格配置详情。
        """
        return pulumi.get(self, "hot_node_storage_spec")

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

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        自定义设置实例名称。只能包含中文、字母、数字、短横线（-）和下划线（_），开头和结尾不能是数字和短横线（-）。长度在 1～128 个字符内。
        """
        return pulumi.get(self, "instance_name")

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

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

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

    @property
    @pulumi.getter(name="kibanaNodeResourceSpec")
    def kibana_node_resource_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationKibanaNodeResourceSpecArgs']]:
        """
        Kibana 节点的节点规格配置详情。
        """
        return pulumi.get(self, "kibana_node_resource_spec")

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

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

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

    @property
    @pulumi.getter(name="masterNodeResourceSpec")
    def master_node_resource_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationMasterNodeResourceSpecArgs']]:
        """
        Master 节点的节点规格配置详情。
        """
        return pulumi.get(self, "master_node_resource_spec")

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

    @property
    @pulumi.getter(name="masterNodeStorageSpec")
    def master_node_storage_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationMasterNodeStorageSpecArgs']]:
        """
        Master 节点的存储规格配置详情。
        """
        return pulumi.get(self, "master_node_storage_spec")

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

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

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

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

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

    @property
    @pulumi.getter
    def period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        包年包月实例的购买时长，单位：月。
        """
        return pulumi.get(self, "period")

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

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        按需设置云搜索实例所属的项目，有利于云资源的分组管理。项目是提供的一种资源管理方式，有利于维护资源独立、数据安全；同时可从项目维度查看资源消费账单，便于计算云资源使用成本。如需了解更多信息，请参见项目概述
        """
        return pulumi.get(self, "project_name")

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

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例所在区域。
        """
        return pulumi.get(self, "region_id")

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

    @property
    @pulumi.getter
    def subnet(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationSubnetArgs']]:
        """
        设置实例的子网信息。说明设置的子网必须是主可用区中的子网。
        """
        return pulumi.get(self, "subnet")

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

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

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

    @property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        API的版本，取值：2023-01-01。
        """
        return pulumi.get(self, "version")

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

    @property
    @pulumi.getter
    def vpc(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationVpcArgs']]:
        """
        设置实例的私有网络 VPC 信息。
        """
        return pulumi.get(self, "vpc")

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

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

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

    @property
    @pulumi.getter(name="warmNodeResourceSpec")
    def warm_node_resource_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationWarmNodeResourceSpecArgs']]:
        """
        温节点的节点规格配置详情。
        """
        return pulumi.get(self, "warm_node_resource_spec")

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

    @property
    @pulumi.getter(name="warmNodeStorageSpec")
    def warm_node_storage_spec(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationWarmNodeStorageSpecArgs']]:
        """
        温节点的存储规格配置详情。
        """
        return pulumi.get(self, "warm_node_storage_spec")

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

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例所在可用区。说明如果是多可用区部署，则填写多个 ZoneId，使用英文逗号分隔，如cn-beijing-a,cn-beijing-c。最左侧的 ZoneId 为主可用区，其余为备可用区。
        """
        return pulumi.get(self, "zone_id")

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

    @property
    @pulumi.getter(name="zoneNumber")
    def zone_number(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        实例的可用区数量。
        """
        return pulumi.get(self, "zone_number")

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


if not MYPY:
    class InstanceInstanceConfigurationColdNodeResourceSpecArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的显示名称
        """
        memory: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的内存容量，单位 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格。如需了解节点规格类型和详情
        """
elif False:
    InstanceInstanceConfigurationColdNodeResourceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationColdNodeResourceSpecArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[builtins.int]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 memory: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] cpu: 节点规格的 CPU 资源，单位为核（Core）
        :param pulumi.Input[builtins.str] description: 节点规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 节点规格的显示名称
        :param pulumi.Input[builtins.int] memory: 节点规格的内存容量，单位 GiB
        :param pulumi.Input[builtins.str] name: 节点规格。如需了解节点规格类型和详情
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的内存容量，单位 GiB
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格。如需了解节点规格类型和详情
        """
        return pulumi.get(self, "name")

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


if not MYPY:
    class InstanceInstanceConfigurationColdNodeStorageSpecArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的显示名称
        """
        max_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格的最大值，单位为 GiB
        """
        min_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格最小值，单位为 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        当前存储规格值，单位为 GiB
        """
elif False:
    InstanceInstanceConfigurationColdNodeStorageSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationColdNodeStorageSpecArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 max_size: Optional[pulumi.Input[builtins.int]] = None,
                 min_size: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] description: 存储规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 存储规格的显示名称
        :param pulumi.Input[builtins.int] max_size: 存储规格的最大值，单位为 GiB
        :param pulumi.Input[builtins.int] min_size: 存储规格最小值，单位为 GiB
        :param pulumi.Input[builtins.str] name: 存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        :param pulumi.Input[builtins.int] size: 当前存储规格值，单位为 GiB
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格的最大值，单位为 GiB
        """
        return pulumi.get(self, "max_size")

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

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格最小值，单位为 GiB
        """
        return pulumi.get(self, "min_size")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        当前存储规格值，单位为 GiB
        """
        return pulumi.get(self, "size")

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


if not MYPY:
    class InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的显示名称
        """
        memory: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的内存容量，单位 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格。如需了解节点规格类型和详情
        """
elif False:
    InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationCoordinatorNodeResourceSpecArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[builtins.int]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 memory: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] cpu: 节点规格的 CPU 资源，单位为核（Core）
        :param pulumi.Input[builtins.str] description: 节点规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 节点规格的显示名称
        :param pulumi.Input[builtins.int] memory: 节点规格的内存容量，单位 GiB
        :param pulumi.Input[builtins.str] name: 节点规格。如需了解节点规格类型和详情
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的内存容量，单位 GiB
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格。如需了解节点规格类型和详情
        """
        return pulumi.get(self, "name")

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


if not MYPY:
    class InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的显示名称
        """
        max_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格的最大值，单位为 GiB
        """
        min_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格最小值，单位为 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        当前存储规格值，单位为 GiB
        """
elif False:
    InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationCoordinatorNodeStorageSpecArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 max_size: Optional[pulumi.Input[builtins.int]] = None,
                 min_size: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] description: 存储规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 存储规格的显示名称
        :param pulumi.Input[builtins.int] max_size: 存储规格的最大值，单位为 GiB
        :param pulumi.Input[builtins.int] min_size: 存储规格最小值，单位为 GiB
        :param pulumi.Input[builtins.str] name: 存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        :param pulumi.Input[builtins.int] size: 当前存储规格值，单位为 GiB
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格的最大值，单位为 GiB
        """
        return pulumi.get(self, "max_size")

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

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格最小值，单位为 GiB
        """
        return pulumi.get(self, "min_size")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        当前存储规格值，单位为 GiB
        """
        return pulumi.get(self, "size")

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


if not MYPY:
    class InstanceInstanceConfigurationHotNodeResourceSpecArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的 CPU 资源，单位为核（Core）。
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的描述信息。
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的显示名称。
        """
        memory: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的内存容量，单位 GiB。
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格。如需了解节点规格类型和详情，请参见产品规格。
        """
elif False:
    InstanceInstanceConfigurationHotNodeResourceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationHotNodeResourceSpecArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[builtins.int]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 memory: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] cpu: 节点规格的 CPU 资源，单位为核（Core）。
        :param pulumi.Input[builtins.str] description: 节点规格的描述信息。
        :param pulumi.Input[builtins.str] display_name: 节点规格的显示名称。
        :param pulumi.Input[builtins.int] memory: 节点规格的内存容量，单位 GiB。
        :param pulumi.Input[builtins.str] name: 节点规格。如需了解节点规格类型和详情，请参见产品规格。
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的 CPU 资源，单位为核（Core）。
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的描述信息。
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的显示名称。
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的内存容量，单位 GiB。
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格。如需了解节点规格类型和详情，请参见产品规格。
        """
        return pulumi.get(self, "name")

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


if not MYPY:
    class InstanceInstanceConfigurationHotNodeStorageSpecArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的描述信息。
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的显示名称。
        """
        max_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格的最大值，单位为 GiB。
        """
        min_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格最小值，单位为 GiB。
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        配置的可用磁盘空间大小。
        """
elif False:
    InstanceInstanceConfigurationHotNodeStorageSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationHotNodeStorageSpecArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 max_size: Optional[pulumi.Input[builtins.int]] = None,
                 min_size: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] description: 存储规格的描述信息。
        :param pulumi.Input[builtins.str] display_name: 存储规格的显示名称。
        :param pulumi.Input[builtins.int] max_size: 存储规格的最大值，单位为 GiB。
        :param pulumi.Input[builtins.int] min_size: 存储规格最小值，单位为 GiB。
        :param pulumi.Input[builtins.str] name: 存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        :param pulumi.Input[builtins.int] size: 配置的可用磁盘空间大小。
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的描述信息。
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的显示名称。
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格的最大值，单位为 GiB。
        """
        return pulumi.get(self, "max_size")

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

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格最小值，单位为 GiB。
        """
        return pulumi.get(self, "min_size")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        配置的可用磁盘空间大小。
        """
        return pulumi.get(self, "size")

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


if not MYPY:
    class InstanceInstanceConfigurationKibanaNodeResourceSpecArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的显示名称
        """
        memory: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的内存容量，单位 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格。如需了解节点规格类型和详情
        """
elif False:
    InstanceInstanceConfigurationKibanaNodeResourceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationKibanaNodeResourceSpecArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[builtins.int]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 memory: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] cpu: 节点规格的 CPU 资源，单位为核（Core）
        :param pulumi.Input[builtins.str] description: 节点规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 节点规格的显示名称
        :param pulumi.Input[builtins.int] memory: 节点规格的内存容量，单位 GiB
        :param pulumi.Input[builtins.str] name: 节点规格。如需了解节点规格类型和详情
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的内存容量，单位 GiB
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格。如需了解节点规格类型和详情
        """
        return pulumi.get(self, "name")

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


if not MYPY:
    class InstanceInstanceConfigurationMasterNodeResourceSpecArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的显示名称
        """
        memory: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的内存容量，单位 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格。如需了解节点规格类型和详情
        """
elif False:
    InstanceInstanceConfigurationMasterNodeResourceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationMasterNodeResourceSpecArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[builtins.int]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 memory: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] cpu: 节点规格的 CPU 资源，单位为核（Core）
        :param pulumi.Input[builtins.str] description: 节点规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 节点规格的显示名称
        :param pulumi.Input[builtins.int] memory: 节点规格的内存容量，单位 GiB
        :param pulumi.Input[builtins.str] name: 节点规格。如需了解节点规格类型和详情
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的内存容量，单位 GiB
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格。如需了解节点规格类型和详情
        """
        return pulumi.get(self, "name")

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


if not MYPY:
    class InstanceInstanceConfigurationMasterNodeStorageSpecArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的显示名称
        """
        max_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格的最大值，单位为 GiB
        """
        min_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格最小值，单位为 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        当前存储规格值，单位为 GiB
        """
elif False:
    InstanceInstanceConfigurationMasterNodeStorageSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationMasterNodeStorageSpecArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 max_size: Optional[pulumi.Input[builtins.int]] = None,
                 min_size: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] description: 存储规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 存储规格的显示名称
        :param pulumi.Input[builtins.int] max_size: 存储规格的最大值，单位为 GiB
        :param pulumi.Input[builtins.int] min_size: 存储规格最小值，单位为 GiB
        :param pulumi.Input[builtins.str] name: 存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        :param pulumi.Input[builtins.int] size: 当前存储规格值，单位为 GiB
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格的最大值，单位为 GiB
        """
        return pulumi.get(self, "max_size")

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

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格最小值，单位为 GiB
        """
        return pulumi.get(self, "min_size")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        当前存储规格值，单位为 GiB
        """
        return pulumi.get(self, "size")

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


if not MYPY:
    class InstanceInstanceConfigurationNetworkSpecArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        公网IP的带宽上限，默认为“1”，单位：Mbps。
        """
        is_open: NotRequired[pulumi.Input[builtins.bool]]
        """
        开启/关闭
        """
        spec_name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例公网资源规格名称
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        公网应用类型 Elasticsearch：es实例使用。Kibana：Dashboard使用
        """
elif False:
    InstanceInstanceConfigurationNetworkSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationNetworkSpecArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 is_open: Optional[pulumi.Input[builtins.bool]] = None,
                 spec_name: Optional[pulumi.Input[builtins.str]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: 公网IP的带宽上限，默认为“1”，单位：Mbps。
        :param pulumi.Input[builtins.bool] is_open: 开启/关闭
        :param pulumi.Input[builtins.str] spec_name: 实例公网资源规格名称
        :param pulumi.Input[builtins.str] type: 公网应用类型 Elasticsearch：es实例使用。Kibana：Dashboard使用
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if is_open is not None:
            pulumi.set(__self__, "is_open", is_open)
        if spec_name is not None:
            pulumi.set(__self__, "spec_name", spec_name)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        公网IP的带宽上限，默认为“1”，单位：Mbps。
        """
        return pulumi.get(self, "bandwidth")

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

    @property
    @pulumi.getter(name="isOpen")
    def is_open(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        开启/关闭
        """
        return pulumi.get(self, "is_open")

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

    @property
    @pulumi.getter(name="specName")
    def spec_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例公网资源规格名称
        """
        return pulumi.get(self, "spec_name")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        公网应用类型 Elasticsearch：es实例使用。Kibana：Dashboard使用
        """
        return pulumi.get(self, "type")

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


if not MYPY:
    class InstanceInstanceConfigurationNodeSpecsAssignArgsDict(TypedDict):
        extra_performance: NotRequired[pulumi.Input['InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgsDict']]
        """
        磁盘额外性能包相关配置。
        """
        number: NotRequired[pulumi.Input[builtins.int]]
        """
        节点数量。配置数据节点数量时，在不同部署方式下，需要注意以下信息：单可用区部署：建议生产环境至少配置 3 个数据节点，配置 2 个节点时存在脑裂风险。如果启用专有主节点，2 个数据节点不会脑裂。双可用区部署，默认启用专有主节点：建议生产环境至少配置 4 个数据节点，即每个可用区两个数据节点。三可用区部署，默认启用专有主节点：建议生产环境至少配置 6 个数据节点，即每个可用区两个数据节点。数据节点数量可设范围为 1~100，如果有更多数据节点的需求，可申请开白提升配额到 200。配置 Master 节点：如果没有启用专有主节点，那么 Master 节点的配置和数据节点相同，否则 Master 配置是独立的。配置专有主节点，如需启用专有主节点，数量默认配置为 3。配置 Kibana 节点，数量固定为 1。配置协调节点，如需启用，生产环境建议至少 2 个协调节点，可配范围为 2~50。温数据节点：如需启用，生产环境建议至少 3 个温数据节点，最多可配置 100 个。冷数据节点：如需启用，生产环境建议至少 2 个温数据节点，最多可配置 100 个。
        """
        resource_spec_name: NotRequired[pulumi.Input[builtins.str]]
        """
        计算资源规格名称。您可以通过调用DescribeNodeAvailableSpecs接口获取可用的节点规格列表。如需了解规格详情，请参见V2 实例规格
        """
        storage_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储容量，单位为 GiB。默认值为 100GiB，调整步长为 10GiB。说明Kibana 节点的 StorageSize 设置为0，即"StorageSize": 0。专有主节点和协调节点的 StorageSize 默认是 20。
        """
        storage_spec_name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格名称，当前支持的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0。es.volume.essd.flexpl-standard：标准版-高性能云盘-flexpl。说明Kibana 节点的 StorageSpecName 设置为空，即"StorageSpecName": ""。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        节点类型。请先了解节点类型的作用，然后结合业务判断是否需要创建，详情请参见节点类型。Master：Master 节点。Hot：数据节点。Cold：冷数据节点。Warm：温数据节点。Kibana：Kibana 节点。Coordinator：协调节点。
        """
elif False:
    InstanceInstanceConfigurationNodeSpecsAssignArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationNodeSpecsAssignArgs:
    def __init__(__self__, *,
                 extra_performance: Optional[pulumi.Input['InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgs']] = None,
                 number: Optional[pulumi.Input[builtins.int]] = None,
                 resource_spec_name: Optional[pulumi.Input[builtins.str]] = None,
                 storage_size: Optional[pulumi.Input[builtins.int]] = None,
                 storage_spec_name: Optional[pulumi.Input[builtins.str]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgs'] extra_performance: 磁盘额外性能包相关配置。
        :param pulumi.Input[builtins.int] number: 节点数量。配置数据节点数量时，在不同部署方式下，需要注意以下信息：单可用区部署：建议生产环境至少配置 3 个数据节点，配置 2 个节点时存在脑裂风险。如果启用专有主节点，2 个数据节点不会脑裂。双可用区部署，默认启用专有主节点：建议生产环境至少配置 4 个数据节点，即每个可用区两个数据节点。三可用区部署，默认启用专有主节点：建议生产环境至少配置 6 个数据节点，即每个可用区两个数据节点。数据节点数量可设范围为 1~100，如果有更多数据节点的需求，可申请开白提升配额到 200。配置 Master 节点：如果没有启用专有主节点，那么 Master 节点的配置和数据节点相同，否则 Master 配置是独立的。配置专有主节点，如需启用专有主节点，数量默认配置为 3。配置 Kibana 节点，数量固定为 1。配置协调节点，如需启用，生产环境建议至少 2 个协调节点，可配范围为 2~50。温数据节点：如需启用，生产环境建议至少 3 个温数据节点，最多可配置 100 个。冷数据节点：如需启用，生产环境建议至少 2 个温数据节点，最多可配置 100 个。
        :param pulumi.Input[builtins.str] resource_spec_name: 计算资源规格名称。您可以通过调用DescribeNodeAvailableSpecs接口获取可用的节点规格列表。如需了解规格详情，请参见V2 实例规格
        :param pulumi.Input[builtins.int] storage_size: 存储容量，单位为 GiB。默认值为 100GiB，调整步长为 10GiB。说明Kibana 节点的 StorageSize 设置为0，即"StorageSize": 0。专有主节点和协调节点的 StorageSize 默认是 20。
        :param pulumi.Input[builtins.str] storage_spec_name: 存储规格名称，当前支持的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0。es.volume.essd.flexpl-standard：标准版-高性能云盘-flexpl。说明Kibana 节点的 StorageSpecName 设置为空，即"StorageSpecName": ""。
        :param pulumi.Input[builtins.str] type: 节点类型。请先了解节点类型的作用，然后结合业务判断是否需要创建，详情请参见节点类型。Master：Master 节点。Hot：数据节点。Cold：冷数据节点。Warm：温数据节点。Kibana：Kibana 节点。Coordinator：协调节点。
        """
        if extra_performance is not None:
            pulumi.set(__self__, "extra_performance", extra_performance)
        if number is not None:
            pulumi.set(__self__, "number", number)
        if resource_spec_name is not None:
            pulumi.set(__self__, "resource_spec_name", resource_spec_name)
        if storage_size is not None:
            pulumi.set(__self__, "storage_size", storage_size)
        if storage_spec_name is not None:
            pulumi.set(__self__, "storage_spec_name", storage_spec_name)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="extraPerformance")
    def extra_performance(self) -> Optional[pulumi.Input['InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgs']]:
        """
        磁盘额外性能包相关配置。
        """
        return pulumi.get(self, "extra_performance")

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

    @property
    @pulumi.getter
    def number(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点数量。配置数据节点数量时，在不同部署方式下，需要注意以下信息：单可用区部署：建议生产环境至少配置 3 个数据节点，配置 2 个节点时存在脑裂风险。如果启用专有主节点，2 个数据节点不会脑裂。双可用区部署，默认启用专有主节点：建议生产环境至少配置 4 个数据节点，即每个可用区两个数据节点。三可用区部署，默认启用专有主节点：建议生产环境至少配置 6 个数据节点，即每个可用区两个数据节点。数据节点数量可设范围为 1~100，如果有更多数据节点的需求，可申请开白提升配额到 200。配置 Master 节点：如果没有启用专有主节点，那么 Master 节点的配置和数据节点相同，否则 Master 配置是独立的。配置专有主节点，如需启用专有主节点，数量默认配置为 3。配置 Kibana 节点，数量固定为 1。配置协调节点，如需启用，生产环境建议至少 2 个协调节点，可配范围为 2~50。温数据节点：如需启用，生产环境建议至少 3 个温数据节点，最多可配置 100 个。冷数据节点：如需启用，生产环境建议至少 2 个温数据节点，最多可配置 100 个。
        """
        return pulumi.get(self, "number")

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

    @property
    @pulumi.getter(name="resourceSpecName")
    def resource_spec_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        计算资源规格名称。您可以通过调用DescribeNodeAvailableSpecs接口获取可用的节点规格列表。如需了解规格详情，请参见V2 实例规格
        """
        return pulumi.get(self, "resource_spec_name")

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

    @property
    @pulumi.getter(name="storageSize")
    def storage_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储容量，单位为 GiB。默认值为 100GiB，调整步长为 10GiB。说明Kibana 节点的 StorageSize 设置为0，即"StorageSize": 0。专有主节点和协调节点的 StorageSize 默认是 20。
        """
        return pulumi.get(self, "storage_size")

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

    @property
    @pulumi.getter(name="storageSpecName")
    def storage_spec_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格名称，当前支持的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0。es.volume.essd.flexpl-standard：标准版-高性能云盘-flexpl。说明Kibana 节点的 StorageSpecName 设置为空，即"StorageSpecName": ""。
        """
        return pulumi.get(self, "storage_spec_name")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点类型。请先了解节点类型的作用，然后结合业务判断是否需要创建，详情请参见节点类型。Master：Master 节点。Hot：数据节点。Cold：冷数据节点。Warm：温数据节点。Kibana：Kibana 节点。Coordinator：协调节点。
        """
        return pulumi.get(self, "type")

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


if not MYPY:
    class InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgsDict(TypedDict):
        throughput: NotRequired[pulumi.Input[builtins.int]]
        """
        当您的数据节点选择使用 FlexPL 存储类型，且存储规格配置为 500GiB 及以上时，支持购买带宽包增加磁盘带宽。单位为MiB，调整步长为10MiB。当前支持的存储规格及对应额外性能包吞吐量上限如下：es.volume.essd.flexpl-standard：650
        """
elif False:
    InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationNodeSpecsAssignExtraPerformanceArgs:
    def __init__(__self__, *,
                 throughput: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] throughput: 当您的数据节点选择使用 FlexPL 存储类型，且存储规格配置为 500GiB 及以上时，支持购买带宽包增加磁盘带宽。单位为MiB，调整步长为10MiB。当前支持的存储规格及对应额外性能包吞吐量上限如下：es.volume.essd.flexpl-standard：650
        """
        if throughput is not None:
            pulumi.set(__self__, "throughput", throughput)

    @property
    @pulumi.getter
    def throughput(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        当您的数据节点选择使用 FlexPL 存储类型，且存储规格配置为 500GiB 及以上时，支持购买带宽包增加磁盘带宽。单位为MiB，调整步长为10MiB。当前支持的存储规格及对应额外性能包吞吐量上限如下：es.volume.essd.flexpl-standard：650
        """
        return pulumi.get(self, "throughput")

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


if not MYPY:
    class InstanceInstanceConfigurationSubnetArgsDict(TypedDict):
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        Subnet ID。
        """
        subnet_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Subnet 名称。
        """
elif False:
    InstanceInstanceConfigurationSubnetArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationSubnetArgs:
    def __init__(__self__, *,
                 subnet_id: Optional[pulumi.Input[builtins.str]] = None,
                 subnet_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] subnet_id: Subnet ID。
        :param pulumi.Input[builtins.str] subnet_name: Subnet 名称。
        """
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if subnet_name is not None:
            pulumi.set(__self__, "subnet_name", subnet_name)

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Subnet ID。
        """
        return pulumi.get(self, "subnet_id")

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

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Subnet 名称。
        """
        return pulumi.get(self, "subnet_name")

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


if not MYPY:
    class InstanceInstanceConfigurationTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签键。长度限制为1～128个字符。大小写敏感，不能以空格开头或结尾。允许包含字母、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签值。长度限制为0～256个字符。大小写敏感，不能以空格开头或结尾。允许包含字母、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@
        """
elif False:
    InstanceInstanceConfigurationTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 用户标签的标签键。长度限制为1～128个字符。大小写敏感，不能以空格开头或结尾。允许包含字母、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复
        :param pulumi.Input[builtins.str] value: 用户标签的标签值。长度限制为0～256个字符。大小写敏感，不能以空格开头或结尾。允许包含字母、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        用户标签的标签键。长度限制为1～128个字符。大小写敏感，不能以空格开头或结尾。允许包含字母、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        用户标签的标签值。长度限制为0～256个字符。大小写敏感，不能以空格开头或结尾。允许包含字母、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class InstanceInstanceConfigurationVpcArgsDict(TypedDict):
        vpc_id: NotRequired[pulumi.Input[builtins.str]]
        """
        VPC ID。
        """
        vpc_name: NotRequired[pulumi.Input[builtins.str]]
        """
        VPC 名称。
        """
elif False:
    InstanceInstanceConfigurationVpcArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationVpcArgs:
    def __init__(__self__, *,
                 vpc_id: Optional[pulumi.Input[builtins.str]] = None,
                 vpc_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] vpc_id: VPC ID。
        :param pulumi.Input[builtins.str] vpc_name: VPC 名称。
        """
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)
        if vpc_name is not None:
            pulumi.set(__self__, "vpc_name", vpc_name)

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        VPC ID。
        """
        return pulumi.get(self, "vpc_id")

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

    @property
    @pulumi.getter(name="vpcName")
    def vpc_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        VPC 名称。
        """
        return pulumi.get(self, "vpc_name")

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


if not MYPY:
    class InstanceInstanceConfigurationWarmNodeResourceSpecArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格的显示名称
        """
        memory: NotRequired[pulumi.Input[builtins.int]]
        """
        节点规格的内存容量，单位 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        节点规格。如需了解节点规格类型和详情
        """
elif False:
    InstanceInstanceConfigurationWarmNodeResourceSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationWarmNodeResourceSpecArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input[builtins.int]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 memory: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] cpu: 节点规格的 CPU 资源，单位为核（Core）
        :param pulumi.Input[builtins.str] description: 节点规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 节点规格的显示名称
        :param pulumi.Input[builtins.int] memory: 节点规格的内存容量，单位 GiB
        :param pulumi.Input[builtins.str] name: 节点规格。如需了解节点规格类型和详情
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的 CPU 资源，单位为核（Core）
        """
        return pulumi.get(self, "cpu")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点规格的内存容量，单位 GiB
        """
        return pulumi.get(self, "memory")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        节点规格。如需了解节点规格类型和详情
        """
        return pulumi.get(self, "name")

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


if not MYPY:
    class InstanceInstanceConfigurationWarmNodeStorageSpecArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的描述信息
        """
        display_name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格的显示名称
        """
        max_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格的最大值，单位为 GiB
        """
        min_size: NotRequired[pulumi.Input[builtins.int]]
        """
        存储规格最小值，单位为 GiB
        """
        name: NotRequired[pulumi.Input[builtins.str]]
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        size: NotRequired[pulumi.Input[builtins.int]]
        """
        当前存储规格值，单位为 GiB
        """
elif False:
    InstanceInstanceConfigurationWarmNodeStorageSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceInstanceConfigurationWarmNodeStorageSpecArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 display_name: Optional[pulumi.Input[builtins.str]] = None,
                 max_size: Optional[pulumi.Input[builtins.int]] = None,
                 min_size: Optional[pulumi.Input[builtins.int]] = None,
                 name: Optional[pulumi.Input[builtins.str]] = None,
                 size: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] description: 存储规格的描述信息
        :param pulumi.Input[builtins.str] display_name: 存储规格的显示名称
        :param pulumi.Input[builtins.int] max_size: 存储规格的最大值，单位为 GiB
        :param pulumi.Input[builtins.int] min_size: 存储规格最小值，单位为 GiB
        :param pulumi.Input[builtins.str] name: 存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        :param pulumi.Input[builtins.int] size: 当前存储规格值，单位为 GiB
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if display_name is not None:
            pulumi.set(__self__, "display_name", display_name)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if min_size is not None:
            pulumi.set(__self__, "min_size", min_size)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if size is not None:
            pulumi.set(__self__, "size", size)

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的描述信息
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格的显示名称
        """
        return pulumi.get(self, "display_name")

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

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格的最大值，单位为 GiB
        """
        return pulumi.get(self, "max_size")

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

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        存储规格最小值，单位为 GiB
        """
        return pulumi.get(self, "min_size")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        存储规格，当前的规格如下：es.volume.essd.pl0：标准版-高性能云盘-pl0
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def size(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        当前存储规格值，单位为 GiB
        """
        return pulumi.get(self, "size")

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


if not MYPY:
    class InstanceKibanaConfigArgsDict(TypedDict):
        request_timeout: NotRequired[pulumi.Input[builtins.int]]
        """
        接口请求超时时长，默认为 30000 毫秒，即后端响应时长超过 30 秒时将出现503 Request timed out报错。如果需要正常获得响应、减少 503 报错，您可以选择增加请求超时时长。
        """
        session_keep_alive: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否主动延长会话有效期。true：默认值，表示每次页面请求都会延长会话有效期。false：不会主动延长会话有效期。此种配置下可以实现会话超时过期效果，当登录时长达到 Session 有效时长后，将会自动退出登录。
        """
        session_ttl: NotRequired[pulumi.Input[builtins.int]]
        """
        会话有效时长，默认为 3600000 毫秒（1 小时）。如果您选择将 Session 活动保持设置为否，当登录时长达到 Session 有效时长后，将会自动退出登录。
        """
elif False:
    InstanceKibanaConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceKibanaConfigArgs:
    def __init__(__self__, *,
                 request_timeout: Optional[pulumi.Input[builtins.int]] = None,
                 session_keep_alive: Optional[pulumi.Input[builtins.bool]] = None,
                 session_ttl: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] request_timeout: 接口请求超时时长，默认为 30000 毫秒，即后端响应时长超过 30 秒时将出现503 Request timed out报错。如果需要正常获得响应、减少 503 报错，您可以选择增加请求超时时长。
        :param pulumi.Input[builtins.bool] session_keep_alive: 是否主动延长会话有效期。true：默认值，表示每次页面请求都会延长会话有效期。false：不会主动延长会话有效期。此种配置下可以实现会话超时过期效果，当登录时长达到 Session 有效时长后，将会自动退出登录。
        :param pulumi.Input[builtins.int] session_ttl: 会话有效时长，默认为 3600000 毫秒（1 小时）。如果您选择将 Session 活动保持设置为否，当登录时长达到 Session 有效时长后，将会自动退出登录。
        """
        if request_timeout is not None:
            pulumi.set(__self__, "request_timeout", request_timeout)
        if session_keep_alive is not None:
            pulumi.set(__self__, "session_keep_alive", session_keep_alive)
        if session_ttl is not None:
            pulumi.set(__self__, "session_ttl", session_ttl)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        接口请求超时时长，默认为 30000 毫秒，即后端响应时长超过 30 秒时将出现503 Request timed out报错。如果需要正常获得响应、减少 503 报错，您可以选择增加请求超时时长。
        """
        return pulumi.get(self, "request_timeout")

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

    @property
    @pulumi.getter(name="sessionKeepAlive")
    def session_keep_alive(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否主动延长会话有效期。true：默认值，表示每次页面请求都会延长会话有效期。false：不会主动延长会话有效期。此种配置下可以实现会话超时过期效果，当登录时长达到 Session 有效时长后，将会自动退出登录。
        """
        return pulumi.get(self, "session_keep_alive")

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

    @property
    @pulumi.getter(name="sessionTtl")
    def session_ttl(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        会话有效时长，默认为 3600000 毫秒（1 小时）。如果您选择将 Session 活动保持设置为否，当登录时长达到 Session 有效时长后，将会自动退出登录。
        """
        return pulumi.get(self, "session_ttl")

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


if not MYPY:
    class InstanceSubInstanceArgsDict(TypedDict):
        sub_instance_id: NotRequired[pulumi.Input[builtins.str]]
        """
        企业级 SQL 分析实例 ID。
        """
        sub_instance_status: NotRequired[pulumi.Input[builtins.str]]
        """
        实例状态。
        """
        sub_instance_type: NotRequired[pulumi.Input[builtins.str]]
        """
        实例类型。
        """
elif False:
    InstanceSubInstanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceSubInstanceArgs:
    def __init__(__self__, *,
                 sub_instance_id: Optional[pulumi.Input[builtins.str]] = None,
                 sub_instance_status: Optional[pulumi.Input[builtins.str]] = None,
                 sub_instance_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] sub_instance_id: 企业级 SQL 分析实例 ID。
        :param pulumi.Input[builtins.str] sub_instance_status: 实例状态。
        :param pulumi.Input[builtins.str] sub_instance_type: 实例类型。
        """
        if sub_instance_id is not None:
            pulumi.set(__self__, "sub_instance_id", sub_instance_id)
        if sub_instance_status is not None:
            pulumi.set(__self__, "sub_instance_status", sub_instance_status)
        if sub_instance_type is not None:
            pulumi.set(__self__, "sub_instance_type", sub_instance_type)

    @property
    @pulumi.getter(name="subInstanceId")
    def sub_instance_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        企业级 SQL 分析实例 ID。
        """
        return pulumi.get(self, "sub_instance_id")

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

    @property
    @pulumi.getter(name="subInstanceStatus")
    def sub_instance_status(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例状态。
        """
        return pulumi.get(self, "sub_instance_status")

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

    @property
    @pulumi.getter(name="subInstanceType")
    def sub_instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例类型。
        """
        return pulumi.get(self, "sub_instance_type")

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


if not MYPY:
    class InstanceTransferInfoArgsDict(TypedDict):
        forbid_stop: NotRequired[pulumi.Input[builtins.bool]]
        """
        ForbidStop
        """
        reduce_spec_config: NotRequired[pulumi.Input['InstanceTransferInfoReduceSpecConfigArgsDict']]
        """
        资源信息。
        """
        transfer_progress: NotRequired[pulumi.Input[builtins.float]]
        """
        数据迁移任务进度，百分制。
        """
        transfer_status: NotRequired[pulumi.Input[builtins.str]]
        """
        数据迁移任务状态。
        """
        transfer_task_id: NotRequired[pulumi.Input[builtins.str]]
        """
        数据迁移任务 ID。
        """
elif False:
    InstanceTransferInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceTransferInfoArgs:
    def __init__(__self__, *,
                 forbid_stop: Optional[pulumi.Input[builtins.bool]] = None,
                 reduce_spec_config: Optional[pulumi.Input['InstanceTransferInfoReduceSpecConfigArgs']] = None,
                 transfer_progress: Optional[pulumi.Input[builtins.float]] = None,
                 transfer_status: Optional[pulumi.Input[builtins.str]] = None,
                 transfer_task_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] forbid_stop: ForbidStop
        :param pulumi.Input['InstanceTransferInfoReduceSpecConfigArgs'] reduce_spec_config: 资源信息。
        :param pulumi.Input[builtins.float] transfer_progress: 数据迁移任务进度，百分制。
        :param pulumi.Input[builtins.str] transfer_status: 数据迁移任务状态。
        :param pulumi.Input[builtins.str] transfer_task_id: 数据迁移任务 ID。
        """
        if forbid_stop is not None:
            pulumi.set(__self__, "forbid_stop", forbid_stop)
        if reduce_spec_config is not None:
            pulumi.set(__self__, "reduce_spec_config", reduce_spec_config)
        if transfer_progress is not None:
            pulumi.set(__self__, "transfer_progress", transfer_progress)
        if transfer_status is not None:
            pulumi.set(__self__, "transfer_status", transfer_status)
        if transfer_task_id is not None:
            pulumi.set(__self__, "transfer_task_id", transfer_task_id)

    @property
    @pulumi.getter(name="forbidStop")
    def forbid_stop(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        ForbidStop
        """
        return pulumi.get(self, "forbid_stop")

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

    @property
    @pulumi.getter(name="reduceSpecConfig")
    def reduce_spec_config(self) -> Optional[pulumi.Input['InstanceTransferInfoReduceSpecConfigArgs']]:
        """
        资源信息。
        """
        return pulumi.get(self, "reduce_spec_config")

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

    @property
    @pulumi.getter(name="transferProgress")
    def transfer_progress(self) -> Optional[pulumi.Input[builtins.float]]:
        """
        数据迁移任务进度，百分制。
        """
        return pulumi.get(self, "transfer_progress")

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

    @property
    @pulumi.getter(name="transferStatus")
    def transfer_status(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        数据迁移任务状态。
        """
        return pulumi.get(self, "transfer_status")

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

    @property
    @pulumi.getter(name="transferTaskId")
    def transfer_task_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        数据迁移任务 ID。
        """
        return pulumi.get(self, "transfer_task_id")

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


if not MYPY:
    class InstanceTransferInfoReduceSpecConfigArgsDict(TypedDict):
        cold_node_num: NotRequired[pulumi.Input[builtins.int]]
        """
        冷节点数量。
        """
        data_node_num: NotRequired[pulumi.Input[builtins.int]]
        """
        数据节点数量。
        """
        enable_pure_master: NotRequired[pulumi.Input[builtins.bool]]
        """
        Master 节点是否独立。true：Master 节点独立。false：Master 节点与数据节点重合，即用 Hot 来声明。
        """
        master_node_num: NotRequired[pulumi.Input[builtins.int]]
        """
        Master 节点数量。
        """
        warm_node_num: NotRequired[pulumi.Input[builtins.int]]
        """
        温节点数量。
        """
elif False:
    InstanceTransferInfoReduceSpecConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceTransferInfoReduceSpecConfigArgs:
    def __init__(__self__, *,
                 cold_node_num: Optional[pulumi.Input[builtins.int]] = None,
                 data_node_num: Optional[pulumi.Input[builtins.int]] = None,
                 enable_pure_master: Optional[pulumi.Input[builtins.bool]] = None,
                 master_node_num: Optional[pulumi.Input[builtins.int]] = None,
                 warm_node_num: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] cold_node_num: 冷节点数量。
        :param pulumi.Input[builtins.int] data_node_num: 数据节点数量。
        :param pulumi.Input[builtins.bool] enable_pure_master: Master 节点是否独立。true：Master 节点独立。false：Master 节点与数据节点重合，即用 Hot 来声明。
        :param pulumi.Input[builtins.int] master_node_num: Master 节点数量。
        :param pulumi.Input[builtins.int] warm_node_num: 温节点数量。
        """
        if cold_node_num is not None:
            pulumi.set(__self__, "cold_node_num", cold_node_num)
        if data_node_num is not None:
            pulumi.set(__self__, "data_node_num", data_node_num)
        if enable_pure_master is not None:
            pulumi.set(__self__, "enable_pure_master", enable_pure_master)
        if master_node_num is not None:
            pulumi.set(__self__, "master_node_num", master_node_num)
        if warm_node_num is not None:
            pulumi.set(__self__, "warm_node_num", warm_node_num)

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

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

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

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

    @property
    @pulumi.getter(name="enablePureMaster")
    def enable_pure_master(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Master 节点是否独立。true：Master 节点独立。false：Master 节点与数据节点重合，即用 Hot 来声明。
        """
        return pulumi.get(self, "enable_pure_master")

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

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

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

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

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


