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

__all__ = ['InstanceArgs', 'Instance']

@pulumi.input_type
class InstanceArgs:
    def __init__(__self__, *,
                 instance_configuration: pulumi.Input['InstanceInstanceConfigurationArgs'],
                 maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 maintenance_time: Optional[pulumi.Input[builtins.str]] = None):
        """
        The set of arguments for constructing a Instance resource.
        :param pulumi.Input['InstanceInstanceConfigurationArgs'] instance_configuration: 实例配置详情信息。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] maintenance_days: 实例的可维护日期。
        :param pulumi.Input[builtins.str] maintenance_time: 实例的可维护时间段。
        """
        pulumi.set(__self__, "instance_configuration", instance_configuration)
        if maintenance_days is not None:
            pulumi.set(__self__, "maintenance_days", maintenance_days)
        if maintenance_time is not None:
            pulumi.set(__self__, "maintenance_time", maintenance_time)

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

    @instance_configuration.setter
    def instance_configuration(self, value: pulumi.Input['InstanceInstanceConfigurationArgs']):
        pulumi.set(self, "instance_configuration", value)

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

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

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

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


@pulumi.input_type
class _InstanceState:
    def __init__(__self__, *,
                 cerebro_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 cerebro_private_domain: Optional[pulumi.Input[builtins.str]] = None,
                 cerebro_public_domain: Optional[pulumi.Input[builtins.str]] = None,
                 charge_enabled: Optional[pulumi.Input[builtins.bool]] = None,
                 cluster_id: Optional[pulumi.Input[builtins.str]] = None,
                 create_time: Optional[pulumi.Input[builtins.str]] = None,
                 enable_es_private_domain_public: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_es_private_network: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_es_public_network: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_kibana_private_domain_public: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_kibana_private_network: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_kibana_public_network: Optional[pulumi.Input[builtins.bool]] = None,
                 es_eip: Optional[pulumi.Input[builtins.str]] = None,
                 es_eip_id: Optional[pulumi.Input[builtins.str]] = None,
                 es_private_endpoint: Optional[pulumi.Input[builtins.str]] = None,
                 es_private_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
                 es_private_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
                 es_pub_bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 es_public_endpoint: Optional[pulumi.Input[builtins.str]] = None,
                 es_public_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
                 es_public_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
                 expire_date: Optional[pulumi.Input[builtins.str]] = None,
                 instance_configuration: Optional[pulumi.Input['InstanceInstanceConfigurationArgs']] = None,
                 instance_id: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_config: Optional[pulumi.Input['InstanceKibanaConfigArgs']] = None,
                 kibana_eip: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_eip_id: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_private_domain: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_private_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_private_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_pub_bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 kibana_public_domain: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_public_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
                 kibana_public_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
                 main_zone_id: Optional[pulumi.Input[builtins.str]] = None,
                 maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 maintenance_time: Optional[pulumi.Input[builtins.str]] = None,
                 status: Optional[pulumi.Input[builtins.str]] = None,
                 sub_instance_enable: Optional[pulumi.Input[builtins.str]] = None,
                 sub_instances: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceSubInstanceArgs']]]] = None,
                 support_cold_node: Optional[pulumi.Input[builtins.bool]] = None,
                 total_nodes: Optional[pulumi.Input[builtins.int]] = None,
                 transfer_info: Optional[pulumi.Input['InstanceTransferInfoArgs']] = None,
                 user_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        Input properties used for looking up and filtering Instance resources.
        :param pulumi.Input[builtins.bool] cerebro_enabled: 是否开启 cerebro。true：开启 cerebrofalse：不开启 cerebro
        :param pulumi.Input[builtins.str] cerebro_private_domain: cerebro 私网访问地址。说明Cerebro 和 Kibana 共享域名。如果是历史实例，访问地址有可能是http(s)://kibana-***开头
        :param pulumi.Input[builtins.str] cerebro_public_domain: erebro 公网访问地址。说明Cerebro 和 Kibana 共享域名。如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        :param pulumi.Input[builtins.bool] charge_enabled: 实例是否开启了计费。取值说明如下：true：已开启计费false：未开启计费
        :param pulumi.Input[builtins.str] cluster_id: 实例所属集群的 ID。
        :param pulumi.Input[builtins.str] create_time: 实例的创建时间。
        :param pulumi.Input[builtins.bool] enable_es_private_domain_public: 实例是否开启私网地址公网解析。true：已开启私网地址公网解析false：未开启私网地址公网解析
        :param pulumi.Input[builtins.bool] enable_es_private_network: 实例是否开启了私网访问。true：默认值，开启私网访问false：未开启私网访问
        :param pulumi.Input[builtins.bool] enable_es_public_network: 实例是否开启了公网访问。true：已开启公网访问false：未开启公网访问
        :param pulumi.Input[builtins.bool] enable_kibana_private_domain_public: Kibana 是否开启私网地址公网解析。true：已开启私网地址公网解析false：未开启私网地址公网解析
        :param pulumi.Input[builtins.bool] enable_kibana_private_network: Kibana 是否开启私网访问。true：默认值，已开启私网访问 false：未开启Kibana私网访问
        :param pulumi.Input[builtins.bool] enable_kibana_public_network: Kibana 是否开启了公网访问。true：已开启公网访问 false：未开启公网访问
        :param pulumi.Input[builtins.str] es_eip: 实例所绑定的 EIP。
        :param pulumi.Input[builtins.str] es_eip_id: 实例所绑定的 EIP 的 ID。
        :param pulumi.Input[builtins.str] es_private_endpoint: 实例私网访问地址。
        :param pulumi.Input[builtins.str] es_private_ip_allow_list: 实例私网地址访问白名单。同 ESPrivateIpWhitelist
        :param pulumi.Input[builtins.str] es_private_ip_whitelist: 实例私网地址访问白名单。
        :param pulumi.Input[builtins.int] es_pub_bandwidth: ES公网带宽，单位:Mbps。
        :param pulumi.Input[builtins.str] es_public_endpoint: 实例公网访问地址。
        :param pulumi.Input[builtins.str] es_public_ip_allow_list: 实例公网地址访问白名单。同 ESPublicIpWhitelist
        :param pulumi.Input[builtins.str] es_public_ip_whitelist: 实例公网地址访问白名单。
        :param pulumi.Input[builtins.str] expire_date: 包年包月实例的付费过期时间。
        :param pulumi.Input['InstanceInstanceConfigurationArgs'] instance_configuration: 实例配置详情信息。
        :param pulumi.Input[builtins.str] instance_id: 实例 ID。
        :param pulumi.Input['InstanceKibanaConfigArgs'] kibana_config: Kibana 参数配置。
        :param pulumi.Input[builtins.str] kibana_eip: Kibana 所绑定的 EIP。
        :param pulumi.Input[builtins.str] kibana_eip_id: Kibana 所绑定的 EIP 的 ID。
        :param pulumi.Input[builtins.str] kibana_private_domain: Kibana 私网访问地址。说明如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        :param pulumi.Input[builtins.str] kibana_private_ip_allow_list: Kibana 私网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。同 KibanaPrivateIpWhitelist
        :param pulumi.Input[builtins.str] kibana_private_ip_whitelist: Kibana 私网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。说明Cerebro 和 Kibana 共用一套白名单。
        :param pulumi.Input[builtins.int] kibana_pub_bandwidth: Kibana公网带宽，单位: Mbps
        :param pulumi.Input[builtins.str] kibana_public_domain: Kibana 公网访问地址。说明如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        :param pulumi.Input[builtins.str] kibana_public_ip_allow_list: Kibana 公网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。同 KibanaPublicIpWhitelist
        :param pulumi.Input[builtins.str] kibana_public_ip_whitelist: Kibana 公网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。说明Cerebro 和 Kibana 共用一套白名单
        :param pulumi.Input[builtins.str] main_zone_id: 主可用区
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] maintenance_days: 实例的可维护日期。
        :param pulumi.Input[builtins.str] maintenance_time: 实例的可维护时间段。
        :param pulumi.Input[builtins.str] status: 实例当前状态。
        :param pulumi.Input[builtins.str] sub_instance_enable: 子实例开启情况。
        :param pulumi.Input[builtins.bool] support_cold_node: 是否支持冷节点。
        :param pulumi.Input[builtins.int] total_nodes: 实例的总节点数。
        :param pulumi.Input['InstanceTransferInfoArgs'] transfer_info: 数据迁移任务信息。
        :param pulumi.Input[builtins.str] user_id: 实例所有者的用户 ID。
        """
        if cerebro_enabled is not None:
            pulumi.set(__self__, "cerebro_enabled", cerebro_enabled)
        if cerebro_private_domain is not None:
            pulumi.set(__self__, "cerebro_private_domain", cerebro_private_domain)
        if cerebro_public_domain is not None:
            pulumi.set(__self__, "cerebro_public_domain", cerebro_public_domain)
        if charge_enabled is not None:
            pulumi.set(__self__, "charge_enabled", charge_enabled)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if create_time is not None:
            pulumi.set(__self__, "create_time", create_time)
        if enable_es_private_domain_public is not None:
            pulumi.set(__self__, "enable_es_private_domain_public", enable_es_private_domain_public)
        if enable_es_private_network is not None:
            pulumi.set(__self__, "enable_es_private_network", enable_es_private_network)
        if enable_es_public_network is not None:
            pulumi.set(__self__, "enable_es_public_network", enable_es_public_network)
        if enable_kibana_private_domain_public is not None:
            pulumi.set(__self__, "enable_kibana_private_domain_public", enable_kibana_private_domain_public)
        if enable_kibana_private_network is not None:
            pulumi.set(__self__, "enable_kibana_private_network", enable_kibana_private_network)
        if enable_kibana_public_network is not None:
            pulumi.set(__self__, "enable_kibana_public_network", enable_kibana_public_network)
        if es_eip is not None:
            pulumi.set(__self__, "es_eip", es_eip)
        if es_eip_id is not None:
            pulumi.set(__self__, "es_eip_id", es_eip_id)
        if es_private_endpoint is not None:
            pulumi.set(__self__, "es_private_endpoint", es_private_endpoint)
        if es_private_ip_allow_list is not None:
            pulumi.set(__self__, "es_private_ip_allow_list", es_private_ip_allow_list)
        if es_private_ip_whitelist is not None:
            pulumi.set(__self__, "es_private_ip_whitelist", es_private_ip_whitelist)
        if es_pub_bandwidth is not None:
            pulumi.set(__self__, "es_pub_bandwidth", es_pub_bandwidth)
        if es_public_endpoint is not None:
            pulumi.set(__self__, "es_public_endpoint", es_public_endpoint)
        if es_public_ip_allow_list is not None:
            pulumi.set(__self__, "es_public_ip_allow_list", es_public_ip_allow_list)
        if es_public_ip_whitelist is not None:
            pulumi.set(__self__, "es_public_ip_whitelist", es_public_ip_whitelist)
        if expire_date is not None:
            pulumi.set(__self__, "expire_date", expire_date)
        if instance_configuration is not None:
            pulumi.set(__self__, "instance_configuration", instance_configuration)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if kibana_config is not None:
            pulumi.set(__self__, "kibana_config", kibana_config)
        if kibana_eip is not None:
            pulumi.set(__self__, "kibana_eip", kibana_eip)
        if kibana_eip_id is not None:
            pulumi.set(__self__, "kibana_eip_id", kibana_eip_id)
        if kibana_private_domain is not None:
            pulumi.set(__self__, "kibana_private_domain", kibana_private_domain)
        if kibana_private_ip_allow_list is not None:
            pulumi.set(__self__, "kibana_private_ip_allow_list", kibana_private_ip_allow_list)
        if kibana_private_ip_whitelist is not None:
            pulumi.set(__self__, "kibana_private_ip_whitelist", kibana_private_ip_whitelist)
        if kibana_pub_bandwidth is not None:
            pulumi.set(__self__, "kibana_pub_bandwidth", kibana_pub_bandwidth)
        if kibana_public_domain is not None:
            pulumi.set(__self__, "kibana_public_domain", kibana_public_domain)
        if kibana_public_ip_allow_list is not None:
            pulumi.set(__self__, "kibana_public_ip_allow_list", kibana_public_ip_allow_list)
        if kibana_public_ip_whitelist is not None:
            pulumi.set(__self__, "kibana_public_ip_whitelist", kibana_public_ip_whitelist)
        if main_zone_id is not None:
            pulumi.set(__self__, "main_zone_id", main_zone_id)
        if maintenance_days is not None:
            pulumi.set(__self__, "maintenance_days", maintenance_days)
        if maintenance_time is not None:
            pulumi.set(__self__, "maintenance_time", maintenance_time)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if sub_instance_enable is not None:
            pulumi.set(__self__, "sub_instance_enable", sub_instance_enable)
        if sub_instances is not None:
            pulumi.set(__self__, "sub_instances", sub_instances)
        if support_cold_node is not None:
            pulumi.set(__self__, "support_cold_node", support_cold_node)
        if total_nodes is not None:
            pulumi.set(__self__, "total_nodes", total_nodes)
        if transfer_info is not None:
            pulumi.set(__self__, "transfer_info", transfer_info)
        if user_id is not None:
            pulumi.set(__self__, "user_id", user_id)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="kibanaConfig")
    def kibana_config(self) -> Optional[pulumi.Input['InstanceKibanaConfigArgs']]:
        """
        Kibana 参数配置。
        """
        return pulumi.get(self, "kibana_config")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.type_token("bytepluscc:escloud/instance:Instance")
class Instance(pulumi.CustomResource):
    @overload
    def __init__(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 instance_configuration: Optional[pulumi.Input[Union['InstanceInstanceConfigurationArgs', 'InstanceInstanceConfigurationArgsDict']]] = None,
                 maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 maintenance_time: Optional[pulumi.Input[builtins.str]] = None,
                 __props__=None):
        """
        云搜索服务（Cloud Search）是提供的全托管一站式信息检索和分析平台，兼容 Elasticsearch、OpenSearch、Kibana、Dashboards、Cerebro 以及常用的开源插件，可应用于全文搜索、向量搜索、混合搜索、AI 搜索、时空检索等场景。使用云搜索服务，您可以实现一键部署、弹性扩缩、简化运维，快速构建日志分析、信息检索分析等实际业务。

        ## Import

        ```sh
        $ pulumi import bytepluscc:escloud/instance:Instance example "instance_id"
        ```

        :param str resource_name: The name of the resource.
        :param pulumi.ResourceOptions opts: Options for the resource.
        :param pulumi.Input[Union['InstanceInstanceConfigurationArgs', 'InstanceInstanceConfigurationArgsDict']] instance_configuration: 实例配置详情信息。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] maintenance_days: 实例的可维护日期。
        :param pulumi.Input[builtins.str] maintenance_time: 实例的可维护时间段。
        """
        ...
    @overload
    def __init__(__self__,
                 resource_name: str,
                 args: InstanceArgs,
                 opts: Optional[pulumi.ResourceOptions] = None):
        """
        云搜索服务（Cloud Search）是提供的全托管一站式信息检索和分析平台，兼容 Elasticsearch、OpenSearch、Kibana、Dashboards、Cerebro 以及常用的开源插件，可应用于全文搜索、向量搜索、混合搜索、AI 搜索、时空检索等场景。使用云搜索服务，您可以实现一键部署、弹性扩缩、简化运维，快速构建日志分析、信息检索分析等实际业务。

        ## Import

        ```sh
        $ pulumi import bytepluscc:escloud/instance:Instance example "instance_id"
        ```

        :param str resource_name: The name of the resource.
        :param InstanceArgs args: The arguments to use to populate this resource's properties.
        :param pulumi.ResourceOptions opts: Options for the resource.
        """
        ...
    def __init__(__self__, resource_name: str, *args, **kwargs):
        resource_args, opts = _utilities.get_resource_args_opts(InstanceArgs, pulumi.ResourceOptions, *args, **kwargs)
        if resource_args is not None:
            __self__._internal_init(resource_name, opts, **resource_args.__dict__)
        else:
            __self__._internal_init(resource_name, *args, **kwargs)

    def _internal_init(__self__,
                 resource_name: str,
                 opts: Optional[pulumi.ResourceOptions] = None,
                 instance_configuration: Optional[pulumi.Input[Union['InstanceInstanceConfigurationArgs', 'InstanceInstanceConfigurationArgsDict']]] = None,
                 maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 maintenance_time: Optional[pulumi.Input[builtins.str]] = None,
                 __props__=None):
        opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
        if not isinstance(opts, pulumi.ResourceOptions):
            raise TypeError('Expected resource options to be a ResourceOptions instance')
        if opts.id is None:
            if __props__ is not None:
                raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
            __props__ = InstanceArgs.__new__(InstanceArgs)

            if instance_configuration is None and not opts.urn:
                raise TypeError("Missing required property 'instance_configuration'")
            __props__.__dict__["instance_configuration"] = instance_configuration
            __props__.__dict__["maintenance_days"] = maintenance_days
            __props__.__dict__["maintenance_time"] = maintenance_time
            __props__.__dict__["cerebro_enabled"] = None
            __props__.__dict__["cerebro_private_domain"] = None
            __props__.__dict__["cerebro_public_domain"] = None
            __props__.__dict__["charge_enabled"] = None
            __props__.__dict__["cluster_id"] = None
            __props__.__dict__["create_time"] = None
            __props__.__dict__["enable_es_private_domain_public"] = None
            __props__.__dict__["enable_es_private_network"] = None
            __props__.__dict__["enable_es_public_network"] = None
            __props__.__dict__["enable_kibana_private_domain_public"] = None
            __props__.__dict__["enable_kibana_private_network"] = None
            __props__.__dict__["enable_kibana_public_network"] = None
            __props__.__dict__["es_eip"] = None
            __props__.__dict__["es_eip_id"] = None
            __props__.__dict__["es_private_endpoint"] = None
            __props__.__dict__["es_private_ip_allow_list"] = None
            __props__.__dict__["es_private_ip_whitelist"] = None
            __props__.__dict__["es_pub_bandwidth"] = None
            __props__.__dict__["es_public_endpoint"] = None
            __props__.__dict__["es_public_ip_allow_list"] = None
            __props__.__dict__["es_public_ip_whitelist"] = None
            __props__.__dict__["expire_date"] = None
            __props__.__dict__["instance_id"] = None
            __props__.__dict__["kibana_config"] = None
            __props__.__dict__["kibana_eip"] = None
            __props__.__dict__["kibana_eip_id"] = None
            __props__.__dict__["kibana_private_domain"] = None
            __props__.__dict__["kibana_private_ip_allow_list"] = None
            __props__.__dict__["kibana_private_ip_whitelist"] = None
            __props__.__dict__["kibana_pub_bandwidth"] = None
            __props__.__dict__["kibana_public_domain"] = None
            __props__.__dict__["kibana_public_ip_allow_list"] = None
            __props__.__dict__["kibana_public_ip_whitelist"] = None
            __props__.__dict__["main_zone_id"] = None
            __props__.__dict__["status"] = None
            __props__.__dict__["sub_instance_enable"] = None
            __props__.__dict__["sub_instances"] = None
            __props__.__dict__["support_cold_node"] = None
            __props__.__dict__["total_nodes"] = None
            __props__.__dict__["transfer_info"] = None
            __props__.__dict__["user_id"] = None
        super(Instance, __self__).__init__(
            'bytepluscc:escloud/instance:Instance',
            resource_name,
            __props__,
            opts)

    @staticmethod
    def get(resource_name: str,
            id: pulumi.Input[str],
            opts: Optional[pulumi.ResourceOptions] = None,
            cerebro_enabled: Optional[pulumi.Input[builtins.bool]] = None,
            cerebro_private_domain: Optional[pulumi.Input[builtins.str]] = None,
            cerebro_public_domain: Optional[pulumi.Input[builtins.str]] = None,
            charge_enabled: Optional[pulumi.Input[builtins.bool]] = None,
            cluster_id: Optional[pulumi.Input[builtins.str]] = None,
            create_time: Optional[pulumi.Input[builtins.str]] = None,
            enable_es_private_domain_public: Optional[pulumi.Input[builtins.bool]] = None,
            enable_es_private_network: Optional[pulumi.Input[builtins.bool]] = None,
            enable_es_public_network: Optional[pulumi.Input[builtins.bool]] = None,
            enable_kibana_private_domain_public: Optional[pulumi.Input[builtins.bool]] = None,
            enable_kibana_private_network: Optional[pulumi.Input[builtins.bool]] = None,
            enable_kibana_public_network: Optional[pulumi.Input[builtins.bool]] = None,
            es_eip: Optional[pulumi.Input[builtins.str]] = None,
            es_eip_id: Optional[pulumi.Input[builtins.str]] = None,
            es_private_endpoint: Optional[pulumi.Input[builtins.str]] = None,
            es_private_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
            es_private_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
            es_pub_bandwidth: Optional[pulumi.Input[builtins.int]] = None,
            es_public_endpoint: Optional[pulumi.Input[builtins.str]] = None,
            es_public_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
            es_public_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
            expire_date: Optional[pulumi.Input[builtins.str]] = None,
            instance_configuration: Optional[pulumi.Input[Union['InstanceInstanceConfigurationArgs', 'InstanceInstanceConfigurationArgsDict']]] = None,
            instance_id: Optional[pulumi.Input[builtins.str]] = None,
            kibana_config: Optional[pulumi.Input[Union['InstanceKibanaConfigArgs', 'InstanceKibanaConfigArgsDict']]] = None,
            kibana_eip: Optional[pulumi.Input[builtins.str]] = None,
            kibana_eip_id: Optional[pulumi.Input[builtins.str]] = None,
            kibana_private_domain: Optional[pulumi.Input[builtins.str]] = None,
            kibana_private_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
            kibana_private_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
            kibana_pub_bandwidth: Optional[pulumi.Input[builtins.int]] = None,
            kibana_public_domain: Optional[pulumi.Input[builtins.str]] = None,
            kibana_public_ip_allow_list: Optional[pulumi.Input[builtins.str]] = None,
            kibana_public_ip_whitelist: Optional[pulumi.Input[builtins.str]] = None,
            main_zone_id: Optional[pulumi.Input[builtins.str]] = None,
            maintenance_days: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
            maintenance_time: Optional[pulumi.Input[builtins.str]] = None,
            status: Optional[pulumi.Input[builtins.str]] = None,
            sub_instance_enable: Optional[pulumi.Input[builtins.str]] = None,
            sub_instances: Optional[pulumi.Input[Sequence[pulumi.Input[Union['InstanceSubInstanceArgs', 'InstanceSubInstanceArgsDict']]]]] = None,
            support_cold_node: Optional[pulumi.Input[builtins.bool]] = None,
            total_nodes: Optional[pulumi.Input[builtins.int]] = None,
            transfer_info: Optional[pulumi.Input[Union['InstanceTransferInfoArgs', 'InstanceTransferInfoArgsDict']]] = None,
            user_id: Optional[pulumi.Input[builtins.str]] = None) -> 'Instance':
        """
        Get an existing Instance resource's state with the given name, id, and optional extra
        properties used to qualify the lookup.

        :param str resource_name: The unique name of the resulting resource.
        :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
        :param pulumi.ResourceOptions opts: Options for the resource.
        :param pulumi.Input[builtins.bool] cerebro_enabled: 是否开启 cerebro。true：开启 cerebrofalse：不开启 cerebro
        :param pulumi.Input[builtins.str] cerebro_private_domain: cerebro 私网访问地址。说明Cerebro 和 Kibana 共享域名。如果是历史实例，访问地址有可能是http(s)://kibana-***开头
        :param pulumi.Input[builtins.str] cerebro_public_domain: erebro 公网访问地址。说明Cerebro 和 Kibana 共享域名。如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        :param pulumi.Input[builtins.bool] charge_enabled: 实例是否开启了计费。取值说明如下：true：已开启计费false：未开启计费
        :param pulumi.Input[builtins.str] cluster_id: 实例所属集群的 ID。
        :param pulumi.Input[builtins.str] create_time: 实例的创建时间。
        :param pulumi.Input[builtins.bool] enable_es_private_domain_public: 实例是否开启私网地址公网解析。true：已开启私网地址公网解析false：未开启私网地址公网解析
        :param pulumi.Input[builtins.bool] enable_es_private_network: 实例是否开启了私网访问。true：默认值，开启私网访问false：未开启私网访问
        :param pulumi.Input[builtins.bool] enable_es_public_network: 实例是否开启了公网访问。true：已开启公网访问false：未开启公网访问
        :param pulumi.Input[builtins.bool] enable_kibana_private_domain_public: Kibana 是否开启私网地址公网解析。true：已开启私网地址公网解析false：未开启私网地址公网解析
        :param pulumi.Input[builtins.bool] enable_kibana_private_network: Kibana 是否开启私网访问。true：默认值，已开启私网访问 false：未开启Kibana私网访问
        :param pulumi.Input[builtins.bool] enable_kibana_public_network: Kibana 是否开启了公网访问。true：已开启公网访问 false：未开启公网访问
        :param pulumi.Input[builtins.str] es_eip: 实例所绑定的 EIP。
        :param pulumi.Input[builtins.str] es_eip_id: 实例所绑定的 EIP 的 ID。
        :param pulumi.Input[builtins.str] es_private_endpoint: 实例私网访问地址。
        :param pulumi.Input[builtins.str] es_private_ip_allow_list: 实例私网地址访问白名单。同 ESPrivateIpWhitelist
        :param pulumi.Input[builtins.str] es_private_ip_whitelist: 实例私网地址访问白名单。
        :param pulumi.Input[builtins.int] es_pub_bandwidth: ES公网带宽，单位:Mbps。
        :param pulumi.Input[builtins.str] es_public_endpoint: 实例公网访问地址。
        :param pulumi.Input[builtins.str] es_public_ip_allow_list: 实例公网地址访问白名单。同 ESPublicIpWhitelist
        :param pulumi.Input[builtins.str] es_public_ip_whitelist: 实例公网地址访问白名单。
        :param pulumi.Input[builtins.str] expire_date: 包年包月实例的付费过期时间。
        :param pulumi.Input[Union['InstanceInstanceConfigurationArgs', 'InstanceInstanceConfigurationArgsDict']] instance_configuration: 实例配置详情信息。
        :param pulumi.Input[builtins.str] instance_id: 实例 ID。
        :param pulumi.Input[Union['InstanceKibanaConfigArgs', 'InstanceKibanaConfigArgsDict']] kibana_config: Kibana 参数配置。
        :param pulumi.Input[builtins.str] kibana_eip: Kibana 所绑定的 EIP。
        :param pulumi.Input[builtins.str] kibana_eip_id: Kibana 所绑定的 EIP 的 ID。
        :param pulumi.Input[builtins.str] kibana_private_domain: Kibana 私网访问地址。说明如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        :param pulumi.Input[builtins.str] kibana_private_ip_allow_list: Kibana 私网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。同 KibanaPrivateIpWhitelist
        :param pulumi.Input[builtins.str] kibana_private_ip_whitelist: Kibana 私网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。说明Cerebro 和 Kibana 共用一套白名单。
        :param pulumi.Input[builtins.int] kibana_pub_bandwidth: Kibana公网带宽，单位: Mbps
        :param pulumi.Input[builtins.str] kibana_public_domain: Kibana 公网访问地址。说明如果是历史实例，访问地址有可能是http(s)://kibana-***开头。
        :param pulumi.Input[builtins.str] kibana_public_ip_allow_list: Kibana 公网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。同 KibanaPublicIpWhitelist
        :param pulumi.Input[builtins.str] kibana_public_ip_whitelist: Kibana 公网白名单。只有添加到白名单中的 IP 地址才可以访问可视化工具。说明Cerebro 和 Kibana 共用一套白名单
        :param pulumi.Input[builtins.str] main_zone_id: 主可用区
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] maintenance_days: 实例的可维护日期。
        :param pulumi.Input[builtins.str] maintenance_time: 实例的可维护时间段。
        :param pulumi.Input[builtins.str] status: 实例当前状态。
        :param pulumi.Input[builtins.str] sub_instance_enable: 子实例开启情况。
        :param pulumi.Input[builtins.bool] support_cold_node: 是否支持冷节点。
        :param pulumi.Input[builtins.int] total_nodes: 实例的总节点数。
        :param pulumi.Input[Union['InstanceTransferInfoArgs', 'InstanceTransferInfoArgsDict']] transfer_info: 数据迁移任务信息。
        :param pulumi.Input[builtins.str] user_id: 实例所有者的用户 ID。
        """
        opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))

        __props__ = _InstanceState.__new__(_InstanceState)

        __props__.__dict__["cerebro_enabled"] = cerebro_enabled
        __props__.__dict__["cerebro_private_domain"] = cerebro_private_domain
        __props__.__dict__["cerebro_public_domain"] = cerebro_public_domain
        __props__.__dict__["charge_enabled"] = charge_enabled
        __props__.__dict__["cluster_id"] = cluster_id
        __props__.__dict__["create_time"] = create_time
        __props__.__dict__["enable_es_private_domain_public"] = enable_es_private_domain_public
        __props__.__dict__["enable_es_private_network"] = enable_es_private_network
        __props__.__dict__["enable_es_public_network"] = enable_es_public_network
        __props__.__dict__["enable_kibana_private_domain_public"] = enable_kibana_private_domain_public
        __props__.__dict__["enable_kibana_private_network"] = enable_kibana_private_network
        __props__.__dict__["enable_kibana_public_network"] = enable_kibana_public_network
        __props__.__dict__["es_eip"] = es_eip
        __props__.__dict__["es_eip_id"] = es_eip_id
        __props__.__dict__["es_private_endpoint"] = es_private_endpoint
        __props__.__dict__["es_private_ip_allow_list"] = es_private_ip_allow_list
        __props__.__dict__["es_private_ip_whitelist"] = es_private_ip_whitelist
        __props__.__dict__["es_pub_bandwidth"] = es_pub_bandwidth
        __props__.__dict__["es_public_endpoint"] = es_public_endpoint
        __props__.__dict__["es_public_ip_allow_list"] = es_public_ip_allow_list
        __props__.__dict__["es_public_ip_whitelist"] = es_public_ip_whitelist
        __props__.__dict__["expire_date"] = expire_date
        __props__.__dict__["instance_configuration"] = instance_configuration
        __props__.__dict__["instance_id"] = instance_id
        __props__.__dict__["kibana_config"] = kibana_config
        __props__.__dict__["kibana_eip"] = kibana_eip
        __props__.__dict__["kibana_eip_id"] = kibana_eip_id
        __props__.__dict__["kibana_private_domain"] = kibana_private_domain
        __props__.__dict__["kibana_private_ip_allow_list"] = kibana_private_ip_allow_list
        __props__.__dict__["kibana_private_ip_whitelist"] = kibana_private_ip_whitelist
        __props__.__dict__["kibana_pub_bandwidth"] = kibana_pub_bandwidth
        __props__.__dict__["kibana_public_domain"] = kibana_public_domain
        __props__.__dict__["kibana_public_ip_allow_list"] = kibana_public_ip_allow_list
        __props__.__dict__["kibana_public_ip_whitelist"] = kibana_public_ip_whitelist
        __props__.__dict__["main_zone_id"] = main_zone_id
        __props__.__dict__["maintenance_days"] = maintenance_days
        __props__.__dict__["maintenance_time"] = maintenance_time
        __props__.__dict__["status"] = status
        __props__.__dict__["sub_instance_enable"] = sub_instance_enable
        __props__.__dict__["sub_instances"] = sub_instances
        __props__.__dict__["support_cold_node"] = support_cold_node
        __props__.__dict__["total_nodes"] = total_nodes
        __props__.__dict__["transfer_info"] = transfer_info
        __props__.__dict__["user_id"] = user_id
        return Instance(resource_name, opts=opts, __props__=__props__)

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="enableKibanaPrivateDomainPublic")
    def enable_kibana_private_domain_public(self) -> pulumi.Output[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) -> pulumi.Output[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) -> pulumi.Output[builtins.bool]:
        """
        Kibana 是否开启了公网访问。true：已开启公网访问 false：未开启公网访问
        """
        return pulumi.get(self, "enable_kibana_public_network")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="subInstances")
    def sub_instances(self) -> pulumi.Output[Sequence['outputs.InstanceSubInstance']]:
        return pulumi.get(self, "sub_instances")

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

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

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

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

