# 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__, allow_list_ids=None, auto_renew=None, charge_status=None, charge_type=None, closed_time=None, config_server_node_spec=None, config_server_storage_space_gb=None, config_servers=None, config_servers_id=None, created_time=None, db_engine=None, db_engine_version=None, db_engine_version_str=None, expired_time=None, id=None, instance_count=None, instance_id=None, instance_name=None, instance_status=None, instance_type=None, mongos=None, mongos_id=None, mongos_node_number=None, mongos_node_spec=None, node_availability_zones=None, node_number=None, node_spec=None, nodes=None, period=None, period_unit=None, private_endpoint=None, project_name=None, read_only_node_number=None, reclaim_time=None, shard_number=None, shards=None, storage_space_gb=None, storage_type=None, subnet_id=None, super_account_name=None, super_account_password=None, tags=None, updated_time=None, vpc_id=None, zone_id=None):
        if allow_list_ids and not isinstance(allow_list_ids, list):
            raise TypeError("Expected argument 'allow_list_ids' to be a list")
        pulumi.set(__self__, "allow_list_ids", allow_list_ids)
        if auto_renew and not isinstance(auto_renew, bool):
            raise TypeError("Expected argument 'auto_renew' to be a bool")
        pulumi.set(__self__, "auto_renew", auto_renew)
        if charge_status and not isinstance(charge_status, str):
            raise TypeError("Expected argument 'charge_status' to be a str")
        pulumi.set(__self__, "charge_status", charge_status)
        if charge_type and not isinstance(charge_type, str):
            raise TypeError("Expected argument 'charge_type' to be a str")
        pulumi.set(__self__, "charge_type", charge_type)
        if closed_time and not isinstance(closed_time, str):
            raise TypeError("Expected argument 'closed_time' to be a str")
        pulumi.set(__self__, "closed_time", closed_time)
        if config_server_node_spec and not isinstance(config_server_node_spec, str):
            raise TypeError("Expected argument 'config_server_node_spec' to be a str")
        pulumi.set(__self__, "config_server_node_spec", config_server_node_spec)
        if config_server_storage_space_gb and not isinstance(config_server_storage_space_gb, int):
            raise TypeError("Expected argument 'config_server_storage_space_gb' to be a int")
        pulumi.set(__self__, "config_server_storage_space_gb", config_server_storage_space_gb)
        if config_servers and not isinstance(config_servers, list):
            raise TypeError("Expected argument 'config_servers' to be a list")
        pulumi.set(__self__, "config_servers", config_servers)
        if config_servers_id and not isinstance(config_servers_id, str):
            raise TypeError("Expected argument 'config_servers_id' to be a str")
        pulumi.set(__self__, "config_servers_id", config_servers_id)
        if created_time and not isinstance(created_time, str):
            raise TypeError("Expected argument 'created_time' to be a str")
        pulumi.set(__self__, "created_time", created_time)
        if db_engine and not isinstance(db_engine, str):
            raise TypeError("Expected argument 'db_engine' to be a str")
        pulumi.set(__self__, "db_engine", db_engine)
        if db_engine_version and not isinstance(db_engine_version, str):
            raise TypeError("Expected argument 'db_engine_version' to be a str")
        pulumi.set(__self__, "db_engine_version", db_engine_version)
        if db_engine_version_str and not isinstance(db_engine_version_str, str):
            raise TypeError("Expected argument 'db_engine_version_str' to be a str")
        pulumi.set(__self__, "db_engine_version_str", db_engine_version_str)
        if expired_time and not isinstance(expired_time, str):
            raise TypeError("Expected argument 'expired_time' to be a str")
        pulumi.set(__self__, "expired_time", expired_time)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if instance_count and not isinstance(instance_count, int):
            raise TypeError("Expected argument 'instance_count' to be a int")
        pulumi.set(__self__, "instance_count", instance_count)
        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 instance_name and not isinstance(instance_name, str):
            raise TypeError("Expected argument 'instance_name' to be a str")
        pulumi.set(__self__, "instance_name", instance_name)
        if instance_status and not isinstance(instance_status, str):
            raise TypeError("Expected argument 'instance_status' to be a str")
        pulumi.set(__self__, "instance_status", instance_status)
        if instance_type and not isinstance(instance_type, str):
            raise TypeError("Expected argument 'instance_type' to be a str")
        pulumi.set(__self__, "instance_type", instance_type)
        if mongos and not isinstance(mongos, list):
            raise TypeError("Expected argument 'mongos' to be a list")
        pulumi.set(__self__, "mongos", mongos)
        if mongos_id and not isinstance(mongos_id, str):
            raise TypeError("Expected argument 'mongos_id' to be a str")
        pulumi.set(__self__, "mongos_id", mongos_id)
        if mongos_node_number and not isinstance(mongos_node_number, int):
            raise TypeError("Expected argument 'mongos_node_number' to be a int")
        pulumi.set(__self__, "mongos_node_number", mongos_node_number)
        if mongos_node_spec and not isinstance(mongos_node_spec, str):
            raise TypeError("Expected argument 'mongos_node_spec' to be a str")
        pulumi.set(__self__, "mongos_node_spec", mongos_node_spec)
        if node_availability_zones and not isinstance(node_availability_zones, list):
            raise TypeError("Expected argument 'node_availability_zones' to be a list")
        pulumi.set(__self__, "node_availability_zones", node_availability_zones)
        if node_number and not isinstance(node_number, int):
            raise TypeError("Expected argument 'node_number' to be a int")
        pulumi.set(__self__, "node_number", node_number)
        if node_spec and not isinstance(node_spec, str):
            raise TypeError("Expected argument 'node_spec' to be a str")
        pulumi.set(__self__, "node_spec", node_spec)
        if nodes and not isinstance(nodes, list):
            raise TypeError("Expected argument 'nodes' to be a list")
        pulumi.set(__self__, "nodes", nodes)
        if period and not isinstance(period, int):
            raise TypeError("Expected argument 'period' to be a int")
        pulumi.set(__self__, "period", period)
        if period_unit and not isinstance(period_unit, str):
            raise TypeError("Expected argument 'period_unit' to be a str")
        pulumi.set(__self__, "period_unit", period_unit)
        if private_endpoint and not isinstance(private_endpoint, str):
            raise TypeError("Expected argument 'private_endpoint' to be a str")
        pulumi.set(__self__, "private_endpoint", private_endpoint)
        if project_name and not isinstance(project_name, str):
            raise TypeError("Expected argument 'project_name' to be a str")
        pulumi.set(__self__, "project_name", project_name)
        if read_only_node_number and not isinstance(read_only_node_number, int):
            raise TypeError("Expected argument 'read_only_node_number' to be a int")
        pulumi.set(__self__, "read_only_node_number", read_only_node_number)
        if reclaim_time and not isinstance(reclaim_time, str):
            raise TypeError("Expected argument 'reclaim_time' to be a str")
        pulumi.set(__self__, "reclaim_time", reclaim_time)
        if shard_number and not isinstance(shard_number, int):
            raise TypeError("Expected argument 'shard_number' to be a int")
        pulumi.set(__self__, "shard_number", shard_number)
        if shards and not isinstance(shards, list):
            raise TypeError("Expected argument 'shards' to be a list")
        pulumi.set(__self__, "shards", shards)
        if storage_space_gb and not isinstance(storage_space_gb, int):
            raise TypeError("Expected argument 'storage_space_gb' to be a int")
        pulumi.set(__self__, "storage_space_gb", storage_space_gb)
        if storage_type and not isinstance(storage_type, str):
            raise TypeError("Expected argument 'storage_type' to be a str")
        pulumi.set(__self__, "storage_type", storage_type)
        if subnet_id and not isinstance(subnet_id, str):
            raise TypeError("Expected argument 'subnet_id' to be a str")
        pulumi.set(__self__, "subnet_id", subnet_id)
        if super_account_name and not isinstance(super_account_name, str):
            raise TypeError("Expected argument 'super_account_name' to be a str")
        pulumi.set(__self__, "super_account_name", super_account_name)
        if super_account_password and not isinstance(super_account_password, str):
            raise TypeError("Expected argument 'super_account_password' to be a str")
        pulumi.set(__self__, "super_account_password", super_account_password)
        if tags and not isinstance(tags, list):
            raise TypeError("Expected argument 'tags' to be a list")
        pulumi.set(__self__, "tags", tags)
        if updated_time and not isinstance(updated_time, str):
            raise TypeError("Expected argument 'updated_time' to be a str")
        pulumi.set(__self__, "updated_time", updated_time)
        if vpc_id and not isinstance(vpc_id, str):
            raise TypeError("Expected argument 'vpc_id' to be a str")
        pulumi.set(__self__, "vpc_id", vpc_id)
        if zone_id and not isinstance(zone_id, str):
            raise TypeError("Expected argument 'zone_id' to be a str")
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="allowListIds")
    def allow_list_ids(self) -> Sequence[builtins.str]:
        """
        白名单 ID 列表。新建实例会被绑定到指定白名单。
        """
        return pulumi.get(self, "allow_list_ids")

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

    @property
    @pulumi.getter(name="chargeStatus")
    def charge_status(self) -> builtins.str:
        """
        实例计费状态，取值范围如下：Normal：正常。WaitingPaid：等待支付。ChangingPayType：计费变更中。Renewing：续费中。Overdue：已到期。Owing：欠费中。Unsubscribing：退订中。
        """
        return pulumi.get(self, "charge_status")

    @property
    @pulumi.getter(name="chargeType")
    def charge_type(self) -> builtins.str:
        """
        实例计费类型，取值范围如下：PostPaid（默认）：按量计费（也称后付费）。Prepaid：包年包月（也称预付费）。
        """
        return pulumi.get(self, "charge_type")

    @property
    @pulumi.getter(name="closedTime")
    def closed_time(self) -> builtins.str:
        """
        计划关停时间（UTC）。
        """
        return pulumi.get(self, "closed_time")

    @property
    @pulumi.getter(name="configServerNodeSpec")
    def config_server_node_spec(self) -> builtins.str:
        """
        分片集群中 ConfigServer 节点的规格码。默认值为 mongo.config.1c2g。
        """
        return pulumi.get(self, "config_server_node_spec")

    @property
    @pulumi.getter(name="configServerStorageSpaceGb")
    def config_server_storage_space_gb(self) -> builtins.int:
        """
        分片集群中 ConfigServer 的存储空间，单位：GiB。步长为 10，默认值：20。
        """
        return pulumi.get(self, "config_server_storage_space_gb")

    @property
    @pulumi.getter(name="configServers")
    def config_servers(self) -> Sequence['outputs.GetInstanceConfigServerResult']:
        """
        ConfigServers 的信息列表。
        """
        return pulumi.get(self, "config_servers")

    @property
    @pulumi.getter(name="configServersId")
    def config_servers_id(self) -> builtins.str:
        """
        ConfigServer 的 ID。
        """
        return pulumi.get(self, "config_servers_id")

    @property
    @pulumi.getter(name="createdTime")
    def created_time(self) -> builtins.str:
        """
        实例创建时间（UTC）。
        """
        return pulumi.get(self, "created_time")

    @property
    @pulumi.getter(name="dbEngine")
    def db_engine(self) -> builtins.str:
        """
        数据库引擎。取值固定为 MongoDB
        """
        return pulumi.get(self, "db_engine")

    @property
    @pulumi.getter(name="dbEngineVersion")
    def db_engine_version(self) -> builtins.str:
        """
        数据库引擎版本，取值范围如下：MongoDB*4*0（默认）：MongoDB 4.0 版本。MongoDB*4*2：MongoDB 4.2 版本。MongoDB*4*4：MongoDB 4.4 版本。MongoDB*5*0：MongoDB 5.0 版本。MongoDB*6*0：MongoDB 6.0 版本。MongoDB*7*0：MongoDB 7.0 版本。
        """
        return pulumi.get(self, "db_engine_version")

    @property
    @pulumi.getter(name="dbEngineVersionStr")
    def db_engine_version_str(self) -> builtins.str:
        """
        数据库引擎版本的字符串。
        """
        return pulumi.get(self, "db_engine_version_str")

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> builtins.str:
        """
        实例到期时间（UTC）。
        """
        return pulumi.get(self, "expired_time")

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

    @property
    @pulumi.getter(name="instanceCount")
    def instance_count(self) -> builtins.int:
        """
        需要创建的实例数量。取值为大于等于 1 的正整数，默认值为1。
        """
        return pulumi.get(self, "instance_count")

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

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> builtins.str:
        """
        实例名称。名称需同时满足如下要求：不能以数字、中划线（-）开头。只能包含中文、字母、数字、下划线（_）和中划线（-）。长度需为 2~64 个字符。
        """
        return pulumi.get(self, "instance_name")

    @property
    @pulumi.getter(name="instanceStatus")
    def instance_status(self) -> builtins.str:
        """
        实例状态。创建中：Creating。运行中：Running。白名单维护中：AllowListMaintaining。变更配置中：Scaling。重启中：Restarting。网络维护中：NetworkMaintaining。恢复中：Restoring。升级版本中：Upgrading。不可用：Unavailable。关停中：Closing。删除中：Deleting。已关停：Closed。SSL SSL变更中：SSLUpdating。主节点切换中：SwitchMastering。角色切换中：RoleChanging。迁移中：Migrating。
        """
        return pulumi.get(self, "instance_status")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> builtins.str:
        """
        MongoDB 的实例类型，取值范围如下：ReplicaSet（默认）：副本集。ShardedCluster：分片集群 。
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def mongos(self) -> Sequence['outputs.GetInstanceMongoResult']:
        """
        Mongos 的信息列表。
        """
        return pulumi.get(self, "mongos")

    @property
    @pulumi.getter(name="mongosId")
    def mongos_id(self) -> builtins.str:
        """
        Mongos 的 ID。
        """
        return pulumi.get(self, "mongos_id")

    @property
    @pulumi.getter(name="mongosNodeNumber")
    def mongos_node_number(self) -> builtins.int:
        """
        分片集群中 Mongos 节点的数量。取值范围：2~32。
        """
        return pulumi.get(self, "mongos_node_number")

    @property
    @pulumi.getter(name="mongosNodeSpec")
    def mongos_node_spec(self) -> builtins.str:
        """
        分片集群中 Mongos 节点的规格码。
        """
        return pulumi.get(self, "mongos_node_spec")

    @property
    @pulumi.getter(name="nodeAvailabilityZones")
    def node_availability_zones(self) -> Sequence['outputs.GetInstanceNodeAvailabilityZoneResult']:
        """
        添加只读节点信息，包括只读节点所在的可用区和数量。
        """
        return pulumi.get(self, "node_availability_zones")

    @property
    @pulumi.getter(name="nodeNumber")
    def node_number(self) -> builtins.int:
        """
        节点数量，其中：当实例类型为副本集（即 InstanceType 取值为 ReplicaSet）时，该参数表示副本集实例的计算节点数量。当实例类型为分片集群（即 InstanceType 取值为 ShardedCluster）时，该参数表示每个 Shard 分片中的节点数量。
        """
        return pulumi.get(self, "node_number")

    @property
    @pulumi.getter(name="nodeSpec")
    def node_spec(self) -> builtins.str:
        """
        实例的规格码。其中：当实例类型为副本集（即 InstanceType 取值为 ReplicaSet）时，该参数表示副本集实例的计算节点规格。当实例类型为分片集群（即 InstanceType 取值为 ShardedCluster）时，该参数表示 Shard 节点的规格。
        """
        return pulumi.get(self, "node_spec")

    @property
    @pulumi.getter
    def nodes(self) -> Sequence['outputs.GetInstanceNodeResult']:
        """
        副本集实例中各节点或分片集群 Shard 分片中各节点的信息列表。
        """
        return pulumi.get(self, "nodes")

    @property
    @pulumi.getter
    def period(self) -> builtins.int:
        """
        包年包月实例的购买时长，其中：当 PeriodUnit 为 Year 时，Period 取值为 1~3。当 PeriodUnit 为 Month 时，Period 取值为 1~9。
        """
        return pulumi.get(self, "period")

    @property
    @pulumi.getter(name="periodUnit")
    def period_unit(self) -> builtins.str:
        """
        指定包年包月实例为包年或者包月类型。取值如下：Year：包年。Month：包月。
        """
        return pulumi.get(self, "period_unit")

    @property
    @pulumi.getter(name="privateEndpoint")
    def private_endpoint(self) -> builtins.str:
        """
        实例私网连接地址的字符串信息。
        """
        return pulumi.get(self, "private_endpoint")

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> builtins.str:
        """
        选择实例所属的项目。若该参数留空，新建实例会默认加入 default 项目。
        """
        return pulumi.get(self, "project_name")

    @property
    @pulumi.getter(name="readOnlyNodeNumber")
    def read_only_node_number(self) -> builtins.int:
        """
        实例的只读节点数量。
        """
        return pulumi.get(self, "read_only_node_number")

    @property
    @pulumi.getter(name="reclaimTime")
    def reclaim_time(self) -> builtins.str:
        """
        实例的计划回收时间（UTC）。
        """
        return pulumi.get(self, "reclaim_time")

    @property
    @pulumi.getter(name="shardNumber")
    def shard_number(self) -> builtins.int:
        """
        分片集群中 Shard 分片的数量。取值范围：2~32。
        """
        return pulumi.get(self, "shard_number")

    @property
    @pulumi.getter
    def shards(self) -> Sequence['outputs.GetInstanceShardResult']:
        """
        Shards 的信息列表。
        """
        return pulumi.get(self, "shards")

    @property
    @pulumi.getter(name="storageSpaceGb")
    def storage_space_gb(self) -> builtins.int:
        """
        副本集实例的总存储空间，或分片集群中单个 Shard 分片的存储空间，单位：GiB，步长为 10。
        """
        return pulumi.get(self, "storage_space_gb")

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> builtins.str:
        """
        实例的存储类型。当前仅支持本地 SSD 盘（即 LocalSSD）存储。
        """
        return pulumi.get(self, "storage_type")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        子网 ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="superAccountName")
    def super_account_name(self) -> builtins.str:
        """
        数据库账号名称。当前仅支持在创建实例时设置超级管理员账号，账号名称固定为 root。
        """
        return pulumi.get(self, "super_account_name")

    @property
    @pulumi.getter(name="superAccountPassword")
    def super_account_password(self) -> builtins.str:
        """
        root 账号的密码。密码需同时满足如下条件：只能为大小写字母、数字及以下特殊字符 _#!@$%^&*()+=-。长度为 8~32 个字符。至少包含大写字母、小写字母、数字或特殊字符中的任意三种。不允许使用极易被破解的弱密码（如 Admin@123）。
        """
        return pulumi.get(self, "super_account_password")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetInstanceTagResult']:
        """
        MongoDB实例的标签信息
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="updatedTime")
    def updated_time(self) -> builtins.str:
        """
        实例的更新时间（UTC）。
        """
        return pulumi.get(self, "updated_time")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> builtins.str:
        """
        私有网络 ID。
        """
        return pulumi.get(self, "vpc_id")

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


class AwaitableGetInstanceResult(GetInstanceResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetInstanceResult(
            allow_list_ids=self.allow_list_ids,
            auto_renew=self.auto_renew,
            charge_status=self.charge_status,
            charge_type=self.charge_type,
            closed_time=self.closed_time,
            config_server_node_spec=self.config_server_node_spec,
            config_server_storage_space_gb=self.config_server_storage_space_gb,
            config_servers=self.config_servers,
            config_servers_id=self.config_servers_id,
            created_time=self.created_time,
            db_engine=self.db_engine,
            db_engine_version=self.db_engine_version,
            db_engine_version_str=self.db_engine_version_str,
            expired_time=self.expired_time,
            id=self.id,
            instance_count=self.instance_count,
            instance_id=self.instance_id,
            instance_name=self.instance_name,
            instance_status=self.instance_status,
            instance_type=self.instance_type,
            mongos=self.mongos,
            mongos_id=self.mongos_id,
            mongos_node_number=self.mongos_node_number,
            mongos_node_spec=self.mongos_node_spec,
            node_availability_zones=self.node_availability_zones,
            node_number=self.node_number,
            node_spec=self.node_spec,
            nodes=self.nodes,
            period=self.period,
            period_unit=self.period_unit,
            private_endpoint=self.private_endpoint,
            project_name=self.project_name,
            read_only_node_number=self.read_only_node_number,
            reclaim_time=self.reclaim_time,
            shard_number=self.shard_number,
            shards=self.shards,
            storage_space_gb=self.storage_space_gb,
            storage_type=self.storage_type,
            subnet_id=self.subnet_id,
            super_account_name=self.super_account_name,
            super_account_password=self.super_account_password,
            tags=self.tags,
            updated_time=self.updated_time,
            vpc_id=self.vpc_id,
            zone_id=self.zone_id)


def get_instance(id: Optional[builtins.str] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetInstanceResult:
    """
    Data Source schema for Byteplus::MongoDB::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:mongodb/getInstance:getInstance', __args__, opts=opts, typ=GetInstanceResult).value

    return AwaitableGetInstanceResult(
        allow_list_ids=pulumi.get(__ret__, 'allow_list_ids'),
        auto_renew=pulumi.get(__ret__, 'auto_renew'),
        charge_status=pulumi.get(__ret__, 'charge_status'),
        charge_type=pulumi.get(__ret__, 'charge_type'),
        closed_time=pulumi.get(__ret__, 'closed_time'),
        config_server_node_spec=pulumi.get(__ret__, 'config_server_node_spec'),
        config_server_storage_space_gb=pulumi.get(__ret__, 'config_server_storage_space_gb'),
        config_servers=pulumi.get(__ret__, 'config_servers'),
        config_servers_id=pulumi.get(__ret__, 'config_servers_id'),
        created_time=pulumi.get(__ret__, 'created_time'),
        db_engine=pulumi.get(__ret__, 'db_engine'),
        db_engine_version=pulumi.get(__ret__, 'db_engine_version'),
        db_engine_version_str=pulumi.get(__ret__, 'db_engine_version_str'),
        expired_time=pulumi.get(__ret__, 'expired_time'),
        id=pulumi.get(__ret__, 'id'),
        instance_count=pulumi.get(__ret__, 'instance_count'),
        instance_id=pulumi.get(__ret__, 'instance_id'),
        instance_name=pulumi.get(__ret__, 'instance_name'),
        instance_status=pulumi.get(__ret__, 'instance_status'),
        instance_type=pulumi.get(__ret__, 'instance_type'),
        mongos=pulumi.get(__ret__, 'mongos'),
        mongos_id=pulumi.get(__ret__, 'mongos_id'),
        mongos_node_number=pulumi.get(__ret__, 'mongos_node_number'),
        mongos_node_spec=pulumi.get(__ret__, 'mongos_node_spec'),
        node_availability_zones=pulumi.get(__ret__, 'node_availability_zones'),
        node_number=pulumi.get(__ret__, 'node_number'),
        node_spec=pulumi.get(__ret__, 'node_spec'),
        nodes=pulumi.get(__ret__, 'nodes'),
        period=pulumi.get(__ret__, 'period'),
        period_unit=pulumi.get(__ret__, 'period_unit'),
        private_endpoint=pulumi.get(__ret__, 'private_endpoint'),
        project_name=pulumi.get(__ret__, 'project_name'),
        read_only_node_number=pulumi.get(__ret__, 'read_only_node_number'),
        reclaim_time=pulumi.get(__ret__, 'reclaim_time'),
        shard_number=pulumi.get(__ret__, 'shard_number'),
        shards=pulumi.get(__ret__, 'shards'),
        storage_space_gb=pulumi.get(__ret__, 'storage_space_gb'),
        storage_type=pulumi.get(__ret__, 'storage_type'),
        subnet_id=pulumi.get(__ret__, 'subnet_id'),
        super_account_name=pulumi.get(__ret__, 'super_account_name'),
        super_account_password=pulumi.get(__ret__, 'super_account_password'),
        tags=pulumi.get(__ret__, 'tags'),
        updated_time=pulumi.get(__ret__, 'updated_time'),
        vpc_id=pulumi.get(__ret__, 'vpc_id'),
        zone_id=pulumi.get(__ret__, 'zone_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::MongoDB::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:mongodb/getInstance:getInstance', __args__, opts=opts, typ=GetInstanceResult)
    return __ret__.apply(lambda __response__: GetInstanceResult(
        allow_list_ids=pulumi.get(__response__, 'allow_list_ids'),
        auto_renew=pulumi.get(__response__, 'auto_renew'),
        charge_status=pulumi.get(__response__, 'charge_status'),
        charge_type=pulumi.get(__response__, 'charge_type'),
        closed_time=pulumi.get(__response__, 'closed_time'),
        config_server_node_spec=pulumi.get(__response__, 'config_server_node_spec'),
        config_server_storage_space_gb=pulumi.get(__response__, 'config_server_storage_space_gb'),
        config_servers=pulumi.get(__response__, 'config_servers'),
        config_servers_id=pulumi.get(__response__, 'config_servers_id'),
        created_time=pulumi.get(__response__, 'created_time'),
        db_engine=pulumi.get(__response__, 'db_engine'),
        db_engine_version=pulumi.get(__response__, 'db_engine_version'),
        db_engine_version_str=pulumi.get(__response__, 'db_engine_version_str'),
        expired_time=pulumi.get(__response__, 'expired_time'),
        id=pulumi.get(__response__, 'id'),
        instance_count=pulumi.get(__response__, 'instance_count'),
        instance_id=pulumi.get(__response__, 'instance_id'),
        instance_name=pulumi.get(__response__, 'instance_name'),
        instance_status=pulumi.get(__response__, 'instance_status'),
        instance_type=pulumi.get(__response__, 'instance_type'),
        mongos=pulumi.get(__response__, 'mongos'),
        mongos_id=pulumi.get(__response__, 'mongos_id'),
        mongos_node_number=pulumi.get(__response__, 'mongos_node_number'),
        mongos_node_spec=pulumi.get(__response__, 'mongos_node_spec'),
        node_availability_zones=pulumi.get(__response__, 'node_availability_zones'),
        node_number=pulumi.get(__response__, 'node_number'),
        node_spec=pulumi.get(__response__, 'node_spec'),
        nodes=pulumi.get(__response__, 'nodes'),
        period=pulumi.get(__response__, 'period'),
        period_unit=pulumi.get(__response__, 'period_unit'),
        private_endpoint=pulumi.get(__response__, 'private_endpoint'),
        project_name=pulumi.get(__response__, 'project_name'),
        read_only_node_number=pulumi.get(__response__, 'read_only_node_number'),
        reclaim_time=pulumi.get(__response__, 'reclaim_time'),
        shard_number=pulumi.get(__response__, 'shard_number'),
        shards=pulumi.get(__response__, 'shards'),
        storage_space_gb=pulumi.get(__response__, 'storage_space_gb'),
        storage_type=pulumi.get(__response__, 'storage_type'),
        subnet_id=pulumi.get(__response__, 'subnet_id'),
        super_account_name=pulumi.get(__response__, 'super_account_name'),
        super_account_password=pulumi.get(__response__, 'super_account_password'),
        tags=pulumi.get(__response__, 'tags'),
        updated_time=pulumi.get(__response__, 'updated_time'),
        vpc_id=pulumi.get(__response__, 'vpc_id'),
        zone_id=pulumi.get(__response__, 'zone_id')))
