# 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, backup_point_name=None, capacity=None, charge_type=None, configure_nodes=None, create_backup=None, create_time=None, data_layout=None, deletion_protection=None, engine_version=None, expired_time=None, id=None, instance_class=None, instance_id=None, instance_name=None, instance_shards=None, maintenance_time=None, max_connections=None, multi_az=None, no_auth_mode=None, node_ids=None, node_number=None, parameter_group_id=None, password=None, port=None, private_address=None, project_name=None, purchase_months=None, reserve_additional_bandwidth=None, service_type=None, shard_capacity=None, shard_number=None, sharded_cluster=None, status=None, subnet_id=None, tags=None, vi_pv6=None, vip=None, visit_addrs=None, vpc_auth_mode=None, vpc_id=None, zone_ids=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 backup_point_name and not isinstance(backup_point_name, str):
            raise TypeError("Expected argument 'backup_point_name' to be a str")
        pulumi.set(__self__, "backup_point_name", backup_point_name)
        if capacity and not isinstance(capacity, dict):
            raise TypeError("Expected argument 'capacity' to be a dict")
        pulumi.set(__self__, "capacity", capacity)
        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 configure_nodes and not isinstance(configure_nodes, list):
            raise TypeError("Expected argument 'configure_nodes' to be a list")
        pulumi.set(__self__, "configure_nodes", configure_nodes)
        if create_backup and not isinstance(create_backup, bool):
            raise TypeError("Expected argument 'create_backup' to be a bool")
        pulumi.set(__self__, "create_backup", create_backup)
        if create_time and not isinstance(create_time, str):
            raise TypeError("Expected argument 'create_time' to be a str")
        pulumi.set(__self__, "create_time", create_time)
        if data_layout and not isinstance(data_layout, str):
            raise TypeError("Expected argument 'data_layout' to be a str")
        pulumi.set(__self__, "data_layout", data_layout)
        if deletion_protection and not isinstance(deletion_protection, str):
            raise TypeError("Expected argument 'deletion_protection' to be a str")
        pulumi.set(__self__, "deletion_protection", deletion_protection)
        if engine_version and not isinstance(engine_version, str):
            raise TypeError("Expected argument 'engine_version' to be a str")
        pulumi.set(__self__, "engine_version", engine_version)
        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_class and not isinstance(instance_class, str):
            raise TypeError("Expected argument 'instance_class' to be a str")
        pulumi.set(__self__, "instance_class", instance_class)
        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_shards and not isinstance(instance_shards, list):
            raise TypeError("Expected argument 'instance_shards' to be a list")
        pulumi.set(__self__, "instance_shards", instance_shards)
        if maintenance_time and not isinstance(maintenance_time, str):
            raise TypeError("Expected argument 'maintenance_time' to be a str")
        pulumi.set(__self__, "maintenance_time", maintenance_time)
        if max_connections and not isinstance(max_connections, int):
            raise TypeError("Expected argument 'max_connections' to be a int")
        pulumi.set(__self__, "max_connections", max_connections)
        if multi_az and not isinstance(multi_az, str):
            raise TypeError("Expected argument 'multi_az' to be a str")
        pulumi.set(__self__, "multi_az", multi_az)
        if no_auth_mode and not isinstance(no_auth_mode, str):
            raise TypeError("Expected argument 'no_auth_mode' to be a str")
        pulumi.set(__self__, "no_auth_mode", no_auth_mode)
        if node_ids and not isinstance(node_ids, list):
            raise TypeError("Expected argument 'node_ids' to be a list")
        pulumi.set(__self__, "node_ids", node_ids)
        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 parameter_group_id and not isinstance(parameter_group_id, str):
            raise TypeError("Expected argument 'parameter_group_id' to be a str")
        pulumi.set(__self__, "parameter_group_id", parameter_group_id)
        if password and not isinstance(password, str):
            raise TypeError("Expected argument 'password' to be a str")
        pulumi.set(__self__, "password", password)
        if port and not isinstance(port, int):
            raise TypeError("Expected argument 'port' to be a int")
        pulumi.set(__self__, "port", port)
        if private_address and not isinstance(private_address, str):
            raise TypeError("Expected argument 'private_address' to be a str")
        pulumi.set(__self__, "private_address", private_address)
        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 purchase_months and not isinstance(purchase_months, int):
            raise TypeError("Expected argument 'purchase_months' to be a int")
        pulumi.set(__self__, "purchase_months", purchase_months)
        if reserve_additional_bandwidth and not isinstance(reserve_additional_bandwidth, bool):
            raise TypeError("Expected argument 'reserve_additional_bandwidth' to be a bool")
        pulumi.set(__self__, "reserve_additional_bandwidth", reserve_additional_bandwidth)
        if service_type and not isinstance(service_type, str):
            raise TypeError("Expected argument 'service_type' to be a str")
        pulumi.set(__self__, "service_type", service_type)
        if shard_capacity and not isinstance(shard_capacity, int):
            raise TypeError("Expected argument 'shard_capacity' to be a int")
        pulumi.set(__self__, "shard_capacity", shard_capacity)
        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 sharded_cluster and not isinstance(sharded_cluster, int):
            raise TypeError("Expected argument 'sharded_cluster' to be a int")
        pulumi.set(__self__, "sharded_cluster", sharded_cluster)
        if status and not isinstance(status, str):
            raise TypeError("Expected argument 'status' to be a str")
        pulumi.set(__self__, "status", status)
        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 tags and not isinstance(tags, list):
            raise TypeError("Expected argument 'tags' to be a list")
        pulumi.set(__self__, "tags", tags)
        if vi_pv6 and not isinstance(vi_pv6, str):
            raise TypeError("Expected argument 'vi_pv6' to be a str")
        pulumi.set(__self__, "vi_pv6", vi_pv6)
        if vip and not isinstance(vip, str):
            raise TypeError("Expected argument 'vip' to be a str")
        pulumi.set(__self__, "vip", vip)
        if visit_addrs and not isinstance(visit_addrs, list):
            raise TypeError("Expected argument 'visit_addrs' to be a list")
        pulumi.set(__self__, "visit_addrs", visit_addrs)
        if vpc_auth_mode and not isinstance(vpc_auth_mode, str):
            raise TypeError("Expected argument 'vpc_auth_mode' to be a str")
        pulumi.set(__self__, "vpc_auth_mode", vpc_auth_mode)
        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_ids and not isinstance(zone_ids, list):
            raise TypeError("Expected argument 'zone_ids' to be a list")
        pulumi.set(__self__, "zone_ids", zone_ids)

    @property
    @pulumi.getter(name="allowListIds")
    def allow_list_ids(self) -> Sequence[builtins.str]:
        """
        白名单 ID 列表。若该参数留空，新建实例默认不加入任何白名单。您可以调用 DescribeAllowLists 接口查询当前账号下指定地域内的所有 IP 白名单信息，包括白名单 ID 信息。每个实例最多支持绑定 100 个白名单，每次可最多批量绑定 100 个白名单。每个实例最多支持绑定 1000 个 IP 地址或 CIDR 格式的 IP 地址段。
        """
        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="backupPointName")
    def backup_point_name(self) -> builtins.str:
        """
        为变更前创建的全量备份设置备份名称。
        """
        return pulumi.get(self, "backup_point_name")

    @property
    @pulumi.getter
    def capacity(self) -> 'outputs.GetInstanceCapacityResult':
        """
        实例的容量信息。
        """
        return pulumi.get(self, "capacity")

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

    @property
    @pulumi.getter(name="configureNodes")
    def configure_nodes(self) -> Sequence['outputs.GetInstanceConfigureNodeResult']:
        """
        设置节点所属的可用区列表。
        """
        return pulumi.get(self, "configure_nodes")

    @property
    @pulumi.getter(name="createBackup")
    def create_backup(self) -> builtins.bool:
        """
        是否在变更前创建备份。
        """
        return pulumi.get(self, "create_backup")

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

    @property
    @pulumi.getter(name="dataLayout")
    def data_layout(self) -> builtins.str:
        """
        实例的数据存储形态。该参数仅对企业版（即ServiceType为Enterprise）实例有意义；社区版（即ServiceType为Basic）实例不涉及数据存储形态，DataLayout取值固定为RAM。若该参数留空，表示不使用数据存储形态进行筛选。
        """
        return pulumi.get(self, "data_layout")

    @property
    @pulumi.getter(name="deletionProtection")
    def deletion_protection(self) -> builtins.str:
        """
        开启或关闭实例删除保护功能。
        """
        return pulumi.get(self, "deletion_protection")

    @property
    @pulumi.getter(name="engineVersion")
    def engine_version(self) -> builtins.str:
        """
        数据库版本号。
        """
        return pulumi.get(self, "engine_version")

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> builtins.str:
        """
        实例到期时间。
        """
        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="instanceClass")
    def instance_class(self) -> builtins.str:
        """
        Redis 实例的类型。取值范围如下：PrimarySecondary：主备实例；Standalone：单节点实例。若该参数留空，表示不使用实例类型条件进行筛选。关于实例类型的更多信息，请参见产品架构。
        """
        return pulumi.get(self, "instance_class")

    @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:
        """
        实例名称。命名规则：不能以数字、中划线（-）开头；只能包含中文、字母、数字、下划线（_）和中划线（-）；长度需要在1~128个字符内。
        """
        return pulumi.get(self, "instance_name")

    @property
    @pulumi.getter(name="instanceShards")
    def instance_shards(self) -> Sequence['outputs.GetInstanceInstanceShardResult']:
        """
        实例中所有 Shard 分片的详情列表。
        """
        return pulumi.get(self, "instance_shards")

    @property
    @pulumi.getter(name="maintenanceTime")
    def maintenance_time(self) -> builtins.str:
        """
        实例的可维护时间段，格式为HH:mm-HH:mm（UTC+8）。
        """
        return pulumi.get(self, "maintenance_time")

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> builtins.int:
        """
        实例当前单分片最大连接数。每分片的默认连接数为10000，您也可以根据业务需要调用ModifyDBInstanceMaxConn接口修改单分片的最大连接数。
        """
        return pulumi.get(self, "max_connections")

    @property
    @pulumi.getter(name="multiAz")
    def multi_az(self) -> builtins.str:
        """
        设置实例的可用区部署方案。
        """
        return pulumi.get(self, "multi_az")

    @property
    @pulumi.getter(name="noAuthMode")
    def no_auth_mode(self) -> builtins.str:
        """
        为新建实例开启或关闭免密访问功能。取值范围如下：open：开启免密访问。close（默认值）：关闭免密访问。
        """
        return pulumi.get(self, "no_auth_mode")

    @property
    @pulumi.getter(name="nodeIds")
    def node_ids(self) -> Sequence[builtins.str]:
        """
        Proxy 和 Server 节点 ID 列表。
        """
        return pulumi.get(self, "node_ids")

    @property
    @pulumi.getter(name="nodeNumber")
    def node_number(self) -> builtins.int:
        """
        每个分片中的节点数。取值范围为1~6。每个账号在每个地域下默认最多可创建4个256MiB规格的节点，若需要调整配额上限为10个，请参见账号配额。取值为1时表示创建单节点实例；取值大于1时表示创建主备实例。关于两种类型实例的功能特性差异详情，请参见功能特性差异。
        """
        return pulumi.get(self, "node_number")

    @property
    @pulumi.getter(name="parameterGroupId")
    def parameter_group_id(self) -> builtins.str:
        """
        需要应用到新实例的参数模板。缓存数据库 Redis 版为每个数据库版本都创建了一份默认的系统参数模板，模板中包含了该版本支持设置的所有参数和默认参数值。若该参数留空，默认会根据您设置的数据库版本（即 EngineVersion）为新建实例选择并应用对应版本的系统参数模板。您可以调用 DescribeParameterGroups 接口查询当前账号和地域下的所有参数模板的基本信息，包括参数模板 ID。
        """
        return pulumi.get(self, "parameter_group_id")

    @property
    @pulumi.getter
    def password(self) -> builtins.str:
        """
        设置默认数据库 default 账号的密码。
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        自定义私网连接地址的端口号。取值范围：1024~65535。若该参数留空，私网连接地址默认使用6379端口。实例创建成功后，还可以修改私网地址的端口号，修改方法请参见修改端口号。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="privateAddress")
    def private_address(self) -> builtins.str:
        """
        实例私网连接地址的域名。
        """
        return pulumi.get(self, "private_address")

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> builtins.str:
        """
        实例所属的项目。
        """
        return pulumi.get(self, "project_name")

    @property
    @pulumi.getter(name="purchaseMonths")
    def purchase_months(self) -> builtins.int:
        """
        购买时长，单位：月。取值范围如下：按月购买：1，2，3，4，5，6，7，8，9。按年购买：12，24，36。当ChargeType为PrePaid时，该参数必填。
        """
        return pulumi.get(self, "purchase_months")

    @property
    @pulumi.getter(name="reserveAdditionalBandwidth")
    def reserve_additional_bandwidth(self) -> builtins.bool:
        """
        设置是否保留额外带宽
        """
        return pulumi.get(self, "reserve_additional_bandwidth")

    @property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> builtins.str:
        """
        实例的服务类型
        """
        return pulumi.get(self, "service_type")

    @property
    @pulumi.getter(name="shardCapacity")
    def shard_capacity(self) -> builtins.int:
        """
        实例中每个分片的内存容量。单位：MiB。
        """
        return pulumi.get(self, "shard_capacity")

    @property
    @pulumi.getter(name="shardNumber")
    def shard_number(self) -> builtins.int:
        """
        实例中的分片数量。取值范围为 2~256。仅当 ShardedCluster 取值为 1（即启用分片集群）时，需要指定该参数。
        """
        return pulumi.get(self, "shard_number")

    @property
    @pulumi.getter(name="shardedCluster")
    def sharded_cluster(self) -> builtins.int:
        """
        是否启用分片集群。取值范围如下：0：不启用。1：启用。
        """
        return pulumi.get(self, "sharded_cluster")

    @property
    @pulumi.getter
    def status(self) -> builtins.str:
        """
        实例的服务类型，取值范围如下：Basic（默认值）：社区版；Enterprise：企业版。
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        设置实例的子网ID。子网具有可用区属性，必须选择目标私有网络中与实例属于同一可用区下的子网。子网是私有网络内的IP地址块私有网络中的所有云资源都必须部署在子网内，子网为云资源分配私网IP地址，您可以调用CreateSubnet接口创建子网。您可以调用DescribeSubnets接口查询指定可用区内的所有子网列表信息，包括子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetInstanceTagResult']:
        """
        设置实例的标签列表。
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="viPv6")
    def vi_pv6(self) -> builtins.str:
        """
        实例私网连接地址所对应的 IPv6 地址。仅当实例使用了 IPv6 地址时才会返回该参数。
        """
        return pulumi.get(self, "vi_pv6")

    @property
    @pulumi.getter
    def vip(self) -> builtins.str:
        """
        实例私网连接地址所对应的 IPv4 地址。
        """
        return pulumi.get(self, "vip")

    @property
    @pulumi.getter(name="visitAddrs")
    def visit_addrs(self) -> Sequence['outputs.GetInstanceVisitAddrResult']:
        """
        连接地址信息。
        """
        return pulumi.get(self, "visit_addrs")

    @property
    @pulumi.getter(name="vpcAuthMode")
    def vpc_auth_mode(self) -> builtins.str:
        """
        开启或关闭免密访问功能。取值范围如下：open：开启免密访问；close：关闭免密访问。参数取值不区分大小写。
        """
        return pulumi.get(self, "vpc_auth_mode")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> builtins.str:
        """
        设置实例的私有网络ID。建议Redis实例与需要连接的ECS实例在同一私有网络，否则它们无法通过内网互通来实现最佳性能。您可以调用CreateVpc接口创建私有网络。您可以调用DescribeVpcs接口查询符合指定条件的私有网络信息，包括私有网络ID。
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="zoneIds")
    def zone_ids(self) -> Sequence[builtins.str]:
        """
        实例所在的可用区列表。
        """
        return pulumi.get(self, "zone_ids")


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,
            backup_point_name=self.backup_point_name,
            capacity=self.capacity,
            charge_type=self.charge_type,
            configure_nodes=self.configure_nodes,
            create_backup=self.create_backup,
            create_time=self.create_time,
            data_layout=self.data_layout,
            deletion_protection=self.deletion_protection,
            engine_version=self.engine_version,
            expired_time=self.expired_time,
            id=self.id,
            instance_class=self.instance_class,
            instance_id=self.instance_id,
            instance_name=self.instance_name,
            instance_shards=self.instance_shards,
            maintenance_time=self.maintenance_time,
            max_connections=self.max_connections,
            multi_az=self.multi_az,
            no_auth_mode=self.no_auth_mode,
            node_ids=self.node_ids,
            node_number=self.node_number,
            parameter_group_id=self.parameter_group_id,
            password=self.password,
            port=self.port,
            private_address=self.private_address,
            project_name=self.project_name,
            purchase_months=self.purchase_months,
            reserve_additional_bandwidth=self.reserve_additional_bandwidth,
            service_type=self.service_type,
            shard_capacity=self.shard_capacity,
            shard_number=self.shard_number,
            sharded_cluster=self.sharded_cluster,
            status=self.status,
            subnet_id=self.subnet_id,
            tags=self.tags,
            vi_pv6=self.vi_pv6,
            vip=self.vip,
            visit_addrs=self.visit_addrs,
            vpc_auth_mode=self.vpc_auth_mode,
            vpc_id=self.vpc_id,
            zone_ids=self.zone_ids)


def get_instance(id: Optional[builtins.str] = None,
                 opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetInstanceResult:
    """
    Data Source schema for Byteplus::Redis::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:redis/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'),
        backup_point_name=pulumi.get(__ret__, 'backup_point_name'),
        capacity=pulumi.get(__ret__, 'capacity'),
        charge_type=pulumi.get(__ret__, 'charge_type'),
        configure_nodes=pulumi.get(__ret__, 'configure_nodes'),
        create_backup=pulumi.get(__ret__, 'create_backup'),
        create_time=pulumi.get(__ret__, 'create_time'),
        data_layout=pulumi.get(__ret__, 'data_layout'),
        deletion_protection=pulumi.get(__ret__, 'deletion_protection'),
        engine_version=pulumi.get(__ret__, 'engine_version'),
        expired_time=pulumi.get(__ret__, 'expired_time'),
        id=pulumi.get(__ret__, 'id'),
        instance_class=pulumi.get(__ret__, 'instance_class'),
        instance_id=pulumi.get(__ret__, 'instance_id'),
        instance_name=pulumi.get(__ret__, 'instance_name'),
        instance_shards=pulumi.get(__ret__, 'instance_shards'),
        maintenance_time=pulumi.get(__ret__, 'maintenance_time'),
        max_connections=pulumi.get(__ret__, 'max_connections'),
        multi_az=pulumi.get(__ret__, 'multi_az'),
        no_auth_mode=pulumi.get(__ret__, 'no_auth_mode'),
        node_ids=pulumi.get(__ret__, 'node_ids'),
        node_number=pulumi.get(__ret__, 'node_number'),
        parameter_group_id=pulumi.get(__ret__, 'parameter_group_id'),
        password=pulumi.get(__ret__, 'password'),
        port=pulumi.get(__ret__, 'port'),
        private_address=pulumi.get(__ret__, 'private_address'),
        project_name=pulumi.get(__ret__, 'project_name'),
        purchase_months=pulumi.get(__ret__, 'purchase_months'),
        reserve_additional_bandwidth=pulumi.get(__ret__, 'reserve_additional_bandwidth'),
        service_type=pulumi.get(__ret__, 'service_type'),
        shard_capacity=pulumi.get(__ret__, 'shard_capacity'),
        shard_number=pulumi.get(__ret__, 'shard_number'),
        sharded_cluster=pulumi.get(__ret__, 'sharded_cluster'),
        status=pulumi.get(__ret__, 'status'),
        subnet_id=pulumi.get(__ret__, 'subnet_id'),
        tags=pulumi.get(__ret__, 'tags'),
        vi_pv6=pulumi.get(__ret__, 'vi_pv6'),
        vip=pulumi.get(__ret__, 'vip'),
        visit_addrs=pulumi.get(__ret__, 'visit_addrs'),
        vpc_auth_mode=pulumi.get(__ret__, 'vpc_auth_mode'),
        vpc_id=pulumi.get(__ret__, 'vpc_id'),
        zone_ids=pulumi.get(__ret__, 'zone_ids'))
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::Redis::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:redis/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'),
        backup_point_name=pulumi.get(__response__, 'backup_point_name'),
        capacity=pulumi.get(__response__, 'capacity'),
        charge_type=pulumi.get(__response__, 'charge_type'),
        configure_nodes=pulumi.get(__response__, 'configure_nodes'),
        create_backup=pulumi.get(__response__, 'create_backup'),
        create_time=pulumi.get(__response__, 'create_time'),
        data_layout=pulumi.get(__response__, 'data_layout'),
        deletion_protection=pulumi.get(__response__, 'deletion_protection'),
        engine_version=pulumi.get(__response__, 'engine_version'),
        expired_time=pulumi.get(__response__, 'expired_time'),
        id=pulumi.get(__response__, 'id'),
        instance_class=pulumi.get(__response__, 'instance_class'),
        instance_id=pulumi.get(__response__, 'instance_id'),
        instance_name=pulumi.get(__response__, 'instance_name'),
        instance_shards=pulumi.get(__response__, 'instance_shards'),
        maintenance_time=pulumi.get(__response__, 'maintenance_time'),
        max_connections=pulumi.get(__response__, 'max_connections'),
        multi_az=pulumi.get(__response__, 'multi_az'),
        no_auth_mode=pulumi.get(__response__, 'no_auth_mode'),
        node_ids=pulumi.get(__response__, 'node_ids'),
        node_number=pulumi.get(__response__, 'node_number'),
        parameter_group_id=pulumi.get(__response__, 'parameter_group_id'),
        password=pulumi.get(__response__, 'password'),
        port=pulumi.get(__response__, 'port'),
        private_address=pulumi.get(__response__, 'private_address'),
        project_name=pulumi.get(__response__, 'project_name'),
        purchase_months=pulumi.get(__response__, 'purchase_months'),
        reserve_additional_bandwidth=pulumi.get(__response__, 'reserve_additional_bandwidth'),
        service_type=pulumi.get(__response__, 'service_type'),
        shard_capacity=pulumi.get(__response__, 'shard_capacity'),
        shard_number=pulumi.get(__response__, 'shard_number'),
        sharded_cluster=pulumi.get(__response__, 'sharded_cluster'),
        status=pulumi.get(__response__, 'status'),
        subnet_id=pulumi.get(__response__, 'subnet_id'),
        tags=pulumi.get(__response__, 'tags'),
        vi_pv6=pulumi.get(__response__, 'vi_pv6'),
        vip=pulumi.get(__response__, 'vip'),
        visit_addrs=pulumi.get(__response__, 'visit_addrs'),
        vpc_auth_mode=pulumi.get(__response__, 'vpc_auth_mode'),
        vpc_id=pulumi.get(__response__, 'vpc_id'),
        zone_ids=pulumi.get(__response__, 'zone_ids')))
