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

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

__all__ = [
    'GetInstanceResult',
    'AwaitableGetInstanceResult',
    'get_instance',
    'get_instance_output',
]

@pulumi.output_type
class GetInstanceResult:
    """
    A collection of values returned by getInstance.
    """
    def __init__(__self__, cerebro_enabled=None, cerebro_private_domain=None, cerebro_public_domain=None, charge_enabled=None, cluster_id=None, create_time=None, enable_es_private_domain_public=None, enable_es_private_network=None, enable_es_public_network=None, enable_kibana_private_domain_public=None, enable_kibana_private_network=None, enable_kibana_public_network=None, es_eip=None, es_eip_id=None, es_private_endpoint=None, es_private_ip_allow_list=None, es_private_ip_whitelist=None, es_pub_bandwidth=None, es_public_endpoint=None, es_public_ip_allow_list=None, es_public_ip_whitelist=None, expire_date=None, id=None, instance_configuration=None, instance_id=None, kibana_config=None, kibana_eip=None, kibana_eip_id=None, kibana_private_domain=None, kibana_private_ip_allow_list=None, kibana_private_ip_whitelist=None, kibana_pub_bandwidth=None, kibana_public_domain=None, kibana_public_ip_allow_list=None, kibana_public_ip_whitelist=None, main_zone_id=None, maintenance_days=None, maintenance_time=None, status=None, sub_instance_enable=None, sub_instances=None, support_cold_node=None, total_nodes=None, transfer_info=None, user_id=None):
        if cerebro_enabled and not isinstance(cerebro_enabled, bool):
            raise TypeError("Expected argument 'cerebro_enabled' to be a bool")
        pulumi.set(__self__, "cerebro_enabled", cerebro_enabled)
        if cerebro_private_domain and not isinstance(cerebro_private_domain, str):
            raise TypeError("Expected argument 'cerebro_private_domain' to be a str")
        pulumi.set(__self__, "cerebro_private_domain", cerebro_private_domain)
        if cerebro_public_domain and not isinstance(cerebro_public_domain, str):
            raise TypeError("Expected argument 'cerebro_public_domain' to be a str")
        pulumi.set(__self__, "cerebro_public_domain", cerebro_public_domain)
        if charge_enabled and not isinstance(charge_enabled, bool):
            raise TypeError("Expected argument 'charge_enabled' to be a bool")
        pulumi.set(__self__, "charge_enabled", charge_enabled)
        if cluster_id and not isinstance(cluster_id, str):
            raise TypeError("Expected argument 'cluster_id' to be a str")
        pulumi.set(__self__, "cluster_id", cluster_id)
        if create_time and not isinstance(create_time, str):
            raise TypeError("Expected argument 'create_time' to be a str")
        pulumi.set(__self__, "create_time", create_time)
        if enable_es_private_domain_public and not isinstance(enable_es_private_domain_public, bool):
            raise TypeError("Expected argument 'enable_es_private_domain_public' to be a bool")
        pulumi.set(__self__, "enable_es_private_domain_public", enable_es_private_domain_public)
        if enable_es_private_network and not isinstance(enable_es_private_network, bool):
            raise TypeError("Expected argument 'enable_es_private_network' to be a bool")
        pulumi.set(__self__, "enable_es_private_network", enable_es_private_network)
        if enable_es_public_network and not isinstance(enable_es_public_network, bool):
            raise TypeError("Expected argument 'enable_es_public_network' to be a bool")
        pulumi.set(__self__, "enable_es_public_network", enable_es_public_network)
        if enable_kibana_private_domain_public and not isinstance(enable_kibana_private_domain_public, bool):
            raise TypeError("Expected argument 'enable_kibana_private_domain_public' to be a bool")
        pulumi.set(__self__, "enable_kibana_private_domain_public", enable_kibana_private_domain_public)
        if enable_kibana_private_network and not isinstance(enable_kibana_private_network, bool):
            raise TypeError("Expected argument 'enable_kibana_private_network' to be a bool")
        pulumi.set(__self__, "enable_kibana_private_network", enable_kibana_private_network)
        if enable_kibana_public_network and not isinstance(enable_kibana_public_network, bool):
            raise TypeError("Expected argument 'enable_kibana_public_network' to be a bool")
        pulumi.set(__self__, "enable_kibana_public_network", enable_kibana_public_network)
        if es_eip and not isinstance(es_eip, str):
            raise TypeError("Expected argument 'es_eip' to be a str")
        pulumi.set(__self__, "es_eip", es_eip)
        if es_eip_id and not isinstance(es_eip_id, str):
            raise TypeError("Expected argument 'es_eip_id' to be a str")
        pulumi.set(__self__, "es_eip_id", es_eip_id)
        if es_private_endpoint and not isinstance(es_private_endpoint, str):
            raise TypeError("Expected argument 'es_private_endpoint' to be a str")
        pulumi.set(__self__, "es_private_endpoint", es_private_endpoint)
        if es_private_ip_allow_list and not isinstance(es_private_ip_allow_list, str):
            raise TypeError("Expected argument 'es_private_ip_allow_list' to be a str")
        pulumi.set(__self__, "es_private_ip_allow_list", es_private_ip_allow_list)
        if es_private_ip_whitelist and not isinstance(es_private_ip_whitelist, str):
            raise TypeError("Expected argument 'es_private_ip_whitelist' to be a str")
        pulumi.set(__self__, "es_private_ip_whitelist", es_private_ip_whitelist)
        if es_pub_bandwidth and not isinstance(es_pub_bandwidth, int):
            raise TypeError("Expected argument 'es_pub_bandwidth' to be a int")
        pulumi.set(__self__, "es_pub_bandwidth", es_pub_bandwidth)
        if es_public_endpoint and not isinstance(es_public_endpoint, str):
            raise TypeError("Expected argument 'es_public_endpoint' to be a str")
        pulumi.set(__self__, "es_public_endpoint", es_public_endpoint)
        if es_public_ip_allow_list and not isinstance(es_public_ip_allow_list, str):
            raise TypeError("Expected argument 'es_public_ip_allow_list' to be a str")
        pulumi.set(__self__, "es_public_ip_allow_list", es_public_ip_allow_list)
        if es_public_ip_whitelist and not isinstance(es_public_ip_whitelist, str):
            raise TypeError("Expected argument 'es_public_ip_whitelist' to be a str")
        pulumi.set(__self__, "es_public_ip_whitelist", es_public_ip_whitelist)
        if expire_date and not isinstance(expire_date, str):
            raise TypeError("Expected argument 'expire_date' to be a str")
        pulumi.set(__self__, "expire_date", expire_date)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if instance_configuration and not isinstance(instance_configuration, dict):
            raise TypeError("Expected argument 'instance_configuration' to be a dict")
        pulumi.set(__self__, "instance_configuration", instance_configuration)
        if instance_id and not isinstance(instance_id, str):
            raise TypeError("Expected argument 'instance_id' to be a str")
        pulumi.set(__self__, "instance_id", instance_id)
        if kibana_config and not isinstance(kibana_config, dict):
            raise TypeError("Expected argument 'kibana_config' to be a dict")
        pulumi.set(__self__, "kibana_config", kibana_config)
        if kibana_eip and not isinstance(kibana_eip, str):
            raise TypeError("Expected argument 'kibana_eip' to be a str")
        pulumi.set(__self__, "kibana_eip", kibana_eip)
        if kibana_eip_id and not isinstance(kibana_eip_id, str):
            raise TypeError("Expected argument 'kibana_eip_id' to be a str")
        pulumi.set(__self__, "kibana_eip_id", kibana_eip_id)
        if kibana_private_domain and not isinstance(kibana_private_domain, str):
            raise TypeError("Expected argument 'kibana_private_domain' to be a str")
        pulumi.set(__self__, "kibana_private_domain", kibana_private_domain)
        if kibana_private_ip_allow_list and not isinstance(kibana_private_ip_allow_list, str):
            raise TypeError("Expected argument 'kibana_private_ip_allow_list' to be a str")
        pulumi.set(__self__, "kibana_private_ip_allow_list", kibana_private_ip_allow_list)
        if kibana_private_ip_whitelist and not isinstance(kibana_private_ip_whitelist, str):
            raise TypeError("Expected argument 'kibana_private_ip_whitelist' to be a str")
        pulumi.set(__self__, "kibana_private_ip_whitelist", kibana_private_ip_whitelist)
        if kibana_pub_bandwidth and not isinstance(kibana_pub_bandwidth, int):
            raise TypeError("Expected argument 'kibana_pub_bandwidth' to be a int")
        pulumi.set(__self__, "kibana_pub_bandwidth", kibana_pub_bandwidth)
        if kibana_public_domain and not isinstance(kibana_public_domain, str):
            raise TypeError("Expected argument 'kibana_public_domain' to be a str")
        pulumi.set(__self__, "kibana_public_domain", kibana_public_domain)
        if kibana_public_ip_allow_list and not isinstance(kibana_public_ip_allow_list, str):
            raise TypeError("Expected argument 'kibana_public_ip_allow_list' to be a str")
        pulumi.set(__self__, "kibana_public_ip_allow_list", kibana_public_ip_allow_list)
        if kibana_public_ip_whitelist and not isinstance(kibana_public_ip_whitelist, str):
            raise TypeError("Expected argument 'kibana_public_ip_whitelist' to be a str")
        pulumi.set(__self__, "kibana_public_ip_whitelist", kibana_public_ip_whitelist)
        if main_zone_id and not isinstance(main_zone_id, str):
            raise TypeError("Expected argument 'main_zone_id' to be a str")
        pulumi.set(__self__, "main_zone_id", main_zone_id)
        if maintenance_days and not isinstance(maintenance_days, list):
            raise TypeError("Expected argument 'maintenance_days' to be a list")
        pulumi.set(__self__, "maintenance_days", maintenance_days)
        if maintenance_time and not isinstance(maintenance_time, str):
            raise TypeError("Expected argument 'maintenance_time' to be a str")
        pulumi.set(__self__, "maintenance_time", maintenance_time)
        if status and not isinstance(status, str):
            raise TypeError("Expected argument 'status' to be a str")
        pulumi.set(__self__, "status", status)
        if sub_instance_enable and not isinstance(sub_instance_enable, str):
            raise TypeError("Expected argument 'sub_instance_enable' to be a str")
        pulumi.set(__self__, "sub_instance_enable", sub_instance_enable)
        if sub_instances and not isinstance(sub_instances, list):
            raise TypeError("Expected argument 'sub_instances' to be a list")
        pulumi.set(__self__, "sub_instances", sub_instances)
        if support_cold_node and not isinstance(support_cold_node, bool):
            raise TypeError("Expected argument 'support_cold_node' to be a bool")
        pulumi.set(__self__, "support_cold_node", support_cold_node)
        if total_nodes and not isinstance(total_nodes, int):
            raise TypeError("Expected argument 'total_nodes' to be a int")
        pulumi.set(__self__, "total_nodes", total_nodes)
        if transfer_info and not isinstance(transfer_info, dict):
            raise TypeError("Expected argument 'transfer_info' to be a dict")
        pulumi.set(__self__, "transfer_info", transfer_info)
        if user_id and not isinstance(user_id, str):
            raise TypeError("Expected argument 'user_id' to be a str")
        pulumi.set(__self__, "user_id", user_id)

    @property
    @pulumi.getter(name="cerebroEnabled")
    def cerebro_enabled(self) -> builtins.bool:
        """
        是否开启 cerebro。true：开启 cerebrofalse：不开启 cerebro
        """
        return pulumi.get(self, "cerebro_enabled")

    @property
    @pulumi.getter(name="cerebroPrivateDomain")
    def cerebro_private_domain(self) -> builtins.str:
        """
        cerebro 私网访问地址。说明Cerebro 和 Kibana 共享域名。如果是历史实例，访问地址有可能是http(s)://kibana-***开头
        """
        return pulumi.get(self, "cerebro_private_domain")

    @property
    @pulumi.getter(name="cerebroPublicDomain")
    def cerebro_public_domain(self) -> builtins.str:
        """
        erebro 公网访问地址。说明Cerebro 和 Kibana 共享域名。如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        """
        return pulumi.get(self, "cerebro_public_domain")

    @property
    @pulumi.getter(name="chargeEnabled")
    def charge_enabled(self) -> builtins.bool:
        """
        实例是否开启了计费。取值说明如下：true：已开启计费false：未开启计费
        """
        return pulumi.get(self, "charge_enabled")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> builtins.str:
        """
        实例所属集群的 ID。
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> builtins.str:
        """
        实例的创建时间。
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter(name="enableEsPrivateDomainPublic")
    def enable_es_private_domain_public(self) -> builtins.bool:
        """
        实例是否开启私网地址公网解析。true：已开启私网地址公网解析false：未开启私网地址公网解析
        """
        return pulumi.get(self, "enable_es_private_domain_public")

    @property
    @pulumi.getter(name="enableEsPrivateNetwork")
    def enable_es_private_network(self) -> builtins.bool:
        """
        实例是否开启了私网访问。true：默认值，开启私网访问false：未开启私网访问
        """
        return pulumi.get(self, "enable_es_private_network")

    @property
    @pulumi.getter(name="enableEsPublicNetwork")
    def enable_es_public_network(self) -> builtins.bool:
        """
        实例是否开启了公网访问。true：已开启公网访问false：未开启公网访问
        """
        return pulumi.get(self, "enable_es_public_network")

    @property
    @pulumi.getter(name="enableKibanaPrivateDomainPublic")
    def enable_kibana_private_domain_public(self) -> builtins.bool:
        """
        Kibana 是否开启私网地址公网解析。true：已开启私网地址公网解析false：未开启私网地址公网解析
        """
        return pulumi.get(self, "enable_kibana_private_domain_public")

    @property
    @pulumi.getter(name="enableKibanaPrivateNetwork")
    def enable_kibana_private_network(self) -> builtins.bool:
        """
        Kibana 是否开启私网访问。true：默认值，已开启私网访问 false：未开启Kibana私网访问
        """
        return pulumi.get(self, "enable_kibana_private_network")

    @property
    @pulumi.getter(name="enableKibanaPublicNetwork")
    def enable_kibana_public_network(self) -> builtins.bool:
        """
        Kibana 是否开启了公网访问。true：已开启公网访问 false：未开启公网访问
        """
        return pulumi.get(self, "enable_kibana_public_network")

    @property
    @pulumi.getter(name="esEip")
    def es_eip(self) -> builtins.str:
        """
        实例所绑定的 EIP。
        """
        return pulumi.get(self, "es_eip")

    @property
    @pulumi.getter(name="esEipId")
    def es_eip_id(self) -> builtins.str:
        """
        实例所绑定的 EIP 的 ID。
        """
        return pulumi.get(self, "es_eip_id")

    @property
    @pulumi.getter(name="esPrivateEndpoint")
    def es_private_endpoint(self) -> builtins.str:
        """
        实例私网访问地址。
        """
        return pulumi.get(self, "es_private_endpoint")

    @property
    @pulumi.getter(name="esPrivateIpAllowList")
    def es_private_ip_allow_list(self) -> builtins.str:
        """
        实例私网地址访问白名单。同 ESPrivateIpWhitelist
        """
        return pulumi.get(self, "es_private_ip_allow_list")

    @property
    @pulumi.getter(name="esPrivateIpWhitelist")
    def es_private_ip_whitelist(self) -> builtins.str:
        """
        实例私网地址访问白名单。
        """
        return pulumi.get(self, "es_private_ip_whitelist")

    @property
    @pulumi.getter(name="esPubBandwidth")
    def es_pub_bandwidth(self) -> builtins.int:
        """
        ES公网带宽，单位:Mbps。
        """
        return pulumi.get(self, "es_pub_bandwidth")

    @property
    @pulumi.getter(name="esPublicEndpoint")
    def es_public_endpoint(self) -> builtins.str:
        """
        实例公网访问地址。
        """
        return pulumi.get(self, "es_public_endpoint")

    @property
    @pulumi.getter(name="esPublicIpAllowList")
    def es_public_ip_allow_list(self) -> builtins.str:
        """
        实例公网地址访问白名单。同 ESPublicIpWhitelist
        """
        return pulumi.get(self, "es_public_ip_allow_list")

    @property
    @pulumi.getter(name="esPublicIpWhitelist")
    def es_public_ip_whitelist(self) -> builtins.str:
        """
        实例公网地址访问白名单。
        """
        return pulumi.get(self, "es_public_ip_whitelist")

    @property
    @pulumi.getter(name="expireDate")
    def expire_date(self) -> builtins.str:
        """
        包年包月实例的付费过期时间。
        """
        return pulumi.get(self, "expire_date")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        Uniquely identifies the resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="instanceConfiguration")
    def instance_configuration(self) -> 'outputs.GetInstanceInstanceConfigurationResult':
        """
        实例配置详情信息。
        """
        return pulumi.get(self, "instance_configuration")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> builtins.str:
        """
        实例 ID。
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="kibanaConfig")
    def kibana_config(self) -> 'outputs.GetInstanceKibanaConfigResult':
        """
        Kibana 参数配置。
        """
        return pulumi.get(self, "kibana_config")

    @property
    @pulumi.getter(name="kibanaEip")
    def kibana_eip(self) -> builtins.str:
        """
        Kibana 所绑定的 EIP。
        """
        return pulumi.get(self, "kibana_eip")

    @property
    @pulumi.getter(name="kibanaEipId")
    def kibana_eip_id(self) -> builtins.str:
        """
        Kibana 所绑定的 EIP 的 ID。
        """
        return pulumi.get(self, "kibana_eip_id")

    @property
    @pulumi.getter(name="kibanaPrivateDomain")
    def kibana_private_domain(self) -> builtins.str:
        """
        Kibana 私网访问地址。说明如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        """
        return pulumi.get(self, "kibana_private_domain")

    @property
    @pulumi.getter(name="kibanaPrivateIpAllowList")
    def kibana_private_ip_allow_list(self) -> builtins.str:
        """
        Kibana 私网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。同 KibanaPrivateIpWhitelist
        """
        return pulumi.get(self, "kibana_private_ip_allow_list")

    @property
    @pulumi.getter(name="kibanaPrivateIpWhitelist")
    def kibana_private_ip_whitelist(self) -> builtins.str:
        """
        Kibana 私网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。说明Cerebro 和 Kibana 共用一套白名单。
        """
        return pulumi.get(self, "kibana_private_ip_whitelist")

    @property
    @pulumi.getter(name="kibanaPubBandwidth")
    def kibana_pub_bandwidth(self) -> builtins.int:
        """
        Kibana公网带宽，单位: Mbps
        """
        return pulumi.get(self, "kibana_pub_bandwidth")

    @property
    @pulumi.getter(name="kibanaPublicDomain")
    def kibana_public_domain(self) -> builtins.str:
        """
        Kibana 公网访问地址。说明如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        """
        return pulumi.get(self, "kibana_public_domain")

    @property
    @pulumi.getter(name="kibanaPublicIpAllowList")
    def kibana_public_ip_allow_list(self) -> builtins.str:
        """
        Kibana 公网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。同 KibanaPublicIpWhitelist
        """
        return pulumi.get(self, "kibana_public_ip_allow_list")

    @property
    @pulumi.getter(name="kibanaPublicIpWhitelist")
    def kibana_public_ip_whitelist(self) -> builtins.str:
        """
        Kibana 公网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。说明Cerebro 和 Kibana 共用一套白名单
        """
        return pulumi.get(self, "kibana_public_ip_whitelist")

    @property
    @pulumi.getter(name="mainZoneId")
    def main_zone_id(self) -> builtins.str:
        """
        主可用区
        """
        return pulumi.get(self, "main_zone_id")

    @property
    @pulumi.getter(name="maintenanceDays")
    def maintenance_days(self) -> Sequence[builtins.str]:
        """
        实例的可维护日期。
        """
        return pulumi.get(self, "maintenance_days")

    @property
    @pulumi.getter(name="maintenanceTime")
    def maintenance_time(self) -> builtins.str:
        """
        实例的可维护时间段。
        """
        return pulumi.get(self, "maintenance_time")

    @property
    @pulumi.getter
    def status(self) -> builtins.str:
        """
        实例当前状态。
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="subInstanceEnable")
    def sub_instance_enable(self) -> builtins.str:
        """
        子实例开启情况。
        """
        return pulumi.get(self, "sub_instance_enable")

    @property
    @pulumi.getter(name="subInstances")
    def sub_instances(self) -> Sequence['outputs.GetInstanceSubInstanceResult']:
        """
        企业级 SQL 分析实例配置信息。
        """
        return pulumi.get(self, "sub_instances")

    @property
    @pulumi.getter(name="supportColdNode")
    def support_cold_node(self) -> builtins.bool:
        """
        是否支持冷节点。
        """
        return pulumi.get(self, "support_cold_node")

    @property
    @pulumi.getter(name="totalNodes")
    def total_nodes(self) -> builtins.int:
        """
        实例的总节点数。
        """
        return pulumi.get(self, "total_nodes")

    @property
    @pulumi.getter(name="transferInfo")
    def transfer_info(self) -> 'outputs.GetInstanceTransferInfoResult':
        """
        数据迁移任务信息。
        """
        return pulumi.get(self, "transfer_info")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> builtins.str:
        """
        实例所有者的用户 ID。
        """
        return pulumi.get(self, "user_id")


class AwaitableGetInstanceResult(GetInstanceResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetInstanceResult(
            cerebro_enabled=self.cerebro_enabled,
            cerebro_private_domain=self.cerebro_private_domain,
            cerebro_public_domain=self.cerebro_public_domain,
            charge_enabled=self.charge_enabled,
            cluster_id=self.cluster_id,
            create_time=self.create_time,
            enable_es_private_domain_public=self.enable_es_private_domain_public,
            enable_es_private_network=self.enable_es_private_network,
            enable_es_public_network=self.enable_es_public_network,
            enable_kibana_private_domain_public=self.enable_kibana_private_domain_public,
            enable_kibana_private_network=self.enable_kibana_private_network,
            enable_kibana_public_network=self.enable_kibana_public_network,
            es_eip=self.es_eip,
            es_eip_id=self.es_eip_id,
            es_private_endpoint=self.es_private_endpoint,
            es_private_ip_allow_list=self.es_private_ip_allow_list,
            es_private_ip_whitelist=self.es_private_ip_whitelist,
            es_pub_bandwidth=self.es_pub_bandwidth,
            es_public_endpoint=self.es_public_endpoint,
            es_public_ip_allow_list=self.es_public_ip_allow_list,
            es_public_ip_whitelist=self.es_public_ip_whitelist,
            expire_date=self.expire_date,
            id=self.id,
            instance_configuration=self.instance_configuration,
            instance_id=self.instance_id,
            kibana_config=self.kibana_config,
            kibana_eip=self.kibana_eip,
            kibana_eip_id=self.kibana_eip_id,
            kibana_private_domain=self.kibana_private_domain,
            kibana_private_ip_allow_list=self.kibana_private_ip_allow_list,
            kibana_private_ip_whitelist=self.kibana_private_ip_whitelist,
            kibana_pub_bandwidth=self.kibana_pub_bandwidth,
            kibana_public_domain=self.kibana_public_domain,
            kibana_public_ip_allow_list=self.kibana_public_ip_allow_list,
            kibana_public_ip_whitelist=self.kibana_public_ip_whitelist,
            main_zone_id=self.main_zone_id,
            maintenance_days=self.maintenance_days,
            maintenance_time=self.maintenance_time,
            status=self.status,
            sub_instance_enable=self.sub_instance_enable,
            sub_instances=self.sub_instances,
            support_cold_node=self.support_cold_node,
            total_nodes=self.total_nodes,
            transfer_info=self.transfer_info,
            user_id=self.user_id)


def get_instance(id: Optional[builtins.str] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetInstanceResult:
    """
    Data Source schema for Byteplus::ESCloud::Instance


    :param builtins.str id: Uniquely identifies the resource.
    """
    __args__ = dict()
    __args__['id'] = id
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('bytepluscc:escloud/getInstance:getInstance', __args__, opts=opts, typ=GetInstanceResult).value

    return AwaitableGetInstanceResult(
        cerebro_enabled=pulumi.get(__ret__, 'cerebro_enabled'),
        cerebro_private_domain=pulumi.get(__ret__, 'cerebro_private_domain'),
        cerebro_public_domain=pulumi.get(__ret__, 'cerebro_public_domain'),
        charge_enabled=pulumi.get(__ret__, 'charge_enabled'),
        cluster_id=pulumi.get(__ret__, 'cluster_id'),
        create_time=pulumi.get(__ret__, 'create_time'),
        enable_es_private_domain_public=pulumi.get(__ret__, 'enable_es_private_domain_public'),
        enable_es_private_network=pulumi.get(__ret__, 'enable_es_private_network'),
        enable_es_public_network=pulumi.get(__ret__, 'enable_es_public_network'),
        enable_kibana_private_domain_public=pulumi.get(__ret__, 'enable_kibana_private_domain_public'),
        enable_kibana_private_network=pulumi.get(__ret__, 'enable_kibana_private_network'),
        enable_kibana_public_network=pulumi.get(__ret__, 'enable_kibana_public_network'),
        es_eip=pulumi.get(__ret__, 'es_eip'),
        es_eip_id=pulumi.get(__ret__, 'es_eip_id'),
        es_private_endpoint=pulumi.get(__ret__, 'es_private_endpoint'),
        es_private_ip_allow_list=pulumi.get(__ret__, 'es_private_ip_allow_list'),
        es_private_ip_whitelist=pulumi.get(__ret__, 'es_private_ip_whitelist'),
        es_pub_bandwidth=pulumi.get(__ret__, 'es_pub_bandwidth'),
        es_public_endpoint=pulumi.get(__ret__, 'es_public_endpoint'),
        es_public_ip_allow_list=pulumi.get(__ret__, 'es_public_ip_allow_list'),
        es_public_ip_whitelist=pulumi.get(__ret__, 'es_public_ip_whitelist'),
        expire_date=pulumi.get(__ret__, 'expire_date'),
        id=pulumi.get(__ret__, 'id'),
        instance_configuration=pulumi.get(__ret__, 'instance_configuration'),
        instance_id=pulumi.get(__ret__, 'instance_id'),
        kibana_config=pulumi.get(__ret__, 'kibana_config'),
        kibana_eip=pulumi.get(__ret__, 'kibana_eip'),
        kibana_eip_id=pulumi.get(__ret__, 'kibana_eip_id'),
        kibana_private_domain=pulumi.get(__ret__, 'kibana_private_domain'),
        kibana_private_ip_allow_list=pulumi.get(__ret__, 'kibana_private_ip_allow_list'),
        kibana_private_ip_whitelist=pulumi.get(__ret__, 'kibana_private_ip_whitelist'),
        kibana_pub_bandwidth=pulumi.get(__ret__, 'kibana_pub_bandwidth'),
        kibana_public_domain=pulumi.get(__ret__, 'kibana_public_domain'),
        kibana_public_ip_allow_list=pulumi.get(__ret__, 'kibana_public_ip_allow_list'),
        kibana_public_ip_whitelist=pulumi.get(__ret__, 'kibana_public_ip_whitelist'),
        main_zone_id=pulumi.get(__ret__, 'main_zone_id'),
        maintenance_days=pulumi.get(__ret__, 'maintenance_days'),
        maintenance_time=pulumi.get(__ret__, 'maintenance_time'),
        status=pulumi.get(__ret__, 'status'),
        sub_instance_enable=pulumi.get(__ret__, 'sub_instance_enable'),
        sub_instances=pulumi.get(__ret__, 'sub_instances'),
        support_cold_node=pulumi.get(__ret__, 'support_cold_node'),
        total_nodes=pulumi.get(__ret__, 'total_nodes'),
        transfer_info=pulumi.get(__ret__, 'transfer_info'),
        user_id=pulumi.get(__ret__, 'user_id'))
def get_instance_output(id: Optional[pulumi.Input[builtins.str]] = None,
                        opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetInstanceResult]:
    """
    Data Source schema for Byteplus::ESCloud::Instance


    :param builtins.str id: Uniquely identifies the resource.
    """
    __args__ = dict()
    __args__['id'] = id
    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke_output('bytepluscc:escloud/getInstance:getInstance', __args__, opts=opts, typ=GetInstanceResult)
    return __ret__.apply(lambda __response__: GetInstanceResult(
        cerebro_enabled=pulumi.get(__response__, 'cerebro_enabled'),
        cerebro_private_domain=pulumi.get(__response__, 'cerebro_private_domain'),
        cerebro_public_domain=pulumi.get(__response__, 'cerebro_public_domain'),
        charge_enabled=pulumi.get(__response__, 'charge_enabled'),
        cluster_id=pulumi.get(__response__, 'cluster_id'),
        create_time=pulumi.get(__response__, 'create_time'),
        enable_es_private_domain_public=pulumi.get(__response__, 'enable_es_private_domain_public'),
        enable_es_private_network=pulumi.get(__response__, 'enable_es_private_network'),
        enable_es_public_network=pulumi.get(__response__, 'enable_es_public_network'),
        enable_kibana_private_domain_public=pulumi.get(__response__, 'enable_kibana_private_domain_public'),
        enable_kibana_private_network=pulumi.get(__response__, 'enable_kibana_private_network'),
        enable_kibana_public_network=pulumi.get(__response__, 'enable_kibana_public_network'),
        es_eip=pulumi.get(__response__, 'es_eip'),
        es_eip_id=pulumi.get(__response__, 'es_eip_id'),
        es_private_endpoint=pulumi.get(__response__, 'es_private_endpoint'),
        es_private_ip_allow_list=pulumi.get(__response__, 'es_private_ip_allow_list'),
        es_private_ip_whitelist=pulumi.get(__response__, 'es_private_ip_whitelist'),
        es_pub_bandwidth=pulumi.get(__response__, 'es_pub_bandwidth'),
        es_public_endpoint=pulumi.get(__response__, 'es_public_endpoint'),
        es_public_ip_allow_list=pulumi.get(__response__, 'es_public_ip_allow_list'),
        es_public_ip_whitelist=pulumi.get(__response__, 'es_public_ip_whitelist'),
        expire_date=pulumi.get(__response__, 'expire_date'),
        id=pulumi.get(__response__, 'id'),
        instance_configuration=pulumi.get(__response__, 'instance_configuration'),
        instance_id=pulumi.get(__response__, 'instance_id'),
        kibana_config=pulumi.get(__response__, 'kibana_config'),
        kibana_eip=pulumi.get(__response__, 'kibana_eip'),
        kibana_eip_id=pulumi.get(__response__, 'kibana_eip_id'),
        kibana_private_domain=pulumi.get(__response__, 'kibana_private_domain'),
        kibana_private_ip_allow_list=pulumi.get(__response__, 'kibana_private_ip_allow_list'),
        kibana_private_ip_whitelist=pulumi.get(__response__, 'kibana_private_ip_whitelist'),
        kibana_pub_bandwidth=pulumi.get(__response__, 'kibana_pub_bandwidth'),
        kibana_public_domain=pulumi.get(__response__, 'kibana_public_domain'),
        kibana_public_ip_allow_list=pulumi.get(__response__, 'kibana_public_ip_allow_list'),
        kibana_public_ip_whitelist=pulumi.get(__response__, 'kibana_public_ip_whitelist'),
        main_zone_id=pulumi.get(__response__, 'main_zone_id'),
        maintenance_days=pulumi.get(__response__, 'maintenance_days'),
        maintenance_time=pulumi.get(__response__, 'maintenance_time'),
        status=pulumi.get(__response__, 'status'),
        sub_instance_enable=pulumi.get(__response__, 'sub_instance_enable'),
        sub_instances=pulumi.get(__response__, 'sub_instances'),
        support_cold_node=pulumi.get(__response__, 'support_cold_node'),
        total_nodes=pulumi.get(__response__, 'total_nodes'),
        transfer_info=pulumi.get(__response__, 'transfer_info'),
        user_id=pulumi.get(__response__, 'user_id')))
