# 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__ = [
    'InstanceChargeDetail',
    'InstanceEndpoint',
    'InstanceEndpointAddress',
    'InstanceMaintenanceWindow',
    'InstanceNode',
    'InstanceTag',
    'GetInstanceChargeDetailResult',
    'GetInstanceEndpointResult',
    'GetInstanceEndpointAddressResult',
    'GetInstanceMaintenanceWindowResult',
    'GetInstanceNodeResult',
    'GetInstanceTagResult',
]

@pulumi.output_type
class InstanceChargeDetail(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoRenew":
            suggest = "auto_renew"
        elif key == "chargeEndTime":
            suggest = "charge_end_time"
        elif key == "chargeStartTime":
            suggest = "charge_start_time"
        elif key == "chargeStatus":
            suggest = "charge_status"
        elif key == "chargeType":
            suggest = "charge_type"
        elif key == "overdueReclaimTime":
            suggest = "overdue_reclaim_time"
        elif key == "overdueTime":
            suggest = "overdue_time"
        elif key == "periodUnit":
            suggest = "period_unit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceChargeDetail. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceChargeDetail.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceChargeDetail.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auto_renew: Optional[builtins.bool] = None,
                 charge_end_time: Optional[builtins.str] = None,
                 charge_start_time: Optional[builtins.str] = None,
                 charge_status: Optional[builtins.str] = None,
                 charge_type: Optional[builtins.str] = None,
                 overdue_reclaim_time: Optional[builtins.str] = None,
                 overdue_time: Optional[builtins.str] = None,
                 period: Optional[builtins.int] = None,
                 period_unit: Optional[builtins.str] = None):
        """
        :param builtins.bool auto_renew: 预付费场景下是否自动续费。取值：true：自动续费。false：不自动续费。
        :param builtins.str charge_end_time: 预付费场景下计费到期的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.str charge_start_time: 计费开始的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.str charge_status: 付费状态：Normal：正常。Overdue：欠费。Shutdown：关停。
        :param builtins.str charge_type: 计费类型。PostPaid：按量计费；PrePaid：包年包月。
        :param builtins.str overdue_reclaim_time: 欠费关停时预计释放时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.str overdue_time: 欠费关停时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.int period: 预付费场景下的购买时长。
        :param builtins.str period_unit: 预付费场景下的购买周期。Month：包月。Year：包年。
        """
        if auto_renew is not None:
            pulumi.set(__self__, "auto_renew", auto_renew)
        if charge_end_time is not None:
            pulumi.set(__self__, "charge_end_time", charge_end_time)
        if charge_start_time is not None:
            pulumi.set(__self__, "charge_start_time", charge_start_time)
        if charge_status is not None:
            pulumi.set(__self__, "charge_status", charge_status)
        if charge_type is not None:
            pulumi.set(__self__, "charge_type", charge_type)
        if overdue_reclaim_time is not None:
            pulumi.set(__self__, "overdue_reclaim_time", overdue_reclaim_time)
        if overdue_time is not None:
            pulumi.set(__self__, "overdue_time", overdue_time)
        if period is not None:
            pulumi.set(__self__, "period", period)
        if period_unit is not None:
            pulumi.set(__self__, "period_unit", period_unit)

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> Optional[builtins.bool]:
        """
        预付费场景下是否自动续费。取值：true：自动续费。false：不自动续费。
        """
        return pulumi.get(self, "auto_renew")

    @property
    @pulumi.getter(name="chargeEndTime")
    def charge_end_time(self) -> Optional[builtins.str]:
        """
        预付费场景下计费到期的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "charge_end_time")

    @property
    @pulumi.getter(name="chargeStartTime")
    def charge_start_time(self) -> Optional[builtins.str]:
        """
        计费开始的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "charge_start_time")

    @property
    @pulumi.getter(name="chargeStatus")
    def charge_status(self) -> Optional[builtins.str]:
        """
        付费状态：Normal：正常。Overdue：欠费。Shutdown：关停。
        """
        return pulumi.get(self, "charge_status")

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

    @property
    @pulumi.getter(name="overdueReclaimTime")
    def overdue_reclaim_time(self) -> Optional[builtins.str]:
        """
        欠费关停时预计释放时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "overdue_reclaim_time")

    @property
    @pulumi.getter(name="overdueTime")
    def overdue_time(self) -> Optional[builtins.str]:
        """
        欠费关停时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "overdue_time")

    @property
    @pulumi.getter
    def period(self) -> Optional[builtins.int]:
        """
        预付费场景下的购买时长。
        """
        return pulumi.get(self, "period")

    @property
    @pulumi.getter(name="periodUnit")
    def period_unit(self) -> Optional[builtins.str]:
        """
        预付费场景下的购买周期。Month：包月。Year：包年。
        """
        return pulumi.get(self, "period_unit")


@pulumi.output_type
class InstanceEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoAddNewNodes":
            suggest = "auto_add_new_nodes"
        elif key == "consistLevel":
            suggest = "consist_level"
        elif key == "consistTimeout":
            suggest = "consist_timeout"
        elif key == "consistTimeoutAction":
            suggest = "consist_timeout_action"
        elif key == "distributedTransaction":
            suggest = "distributed_transaction"
        elif key == "endpointId":
            suggest = "endpoint_id"
        elif key == "endpointName":
            suggest = "endpoint_name"
        elif key == "endpointType":
            suggest = "endpoint_type"
        elif key == "masterAcceptReadRequests":
            suggest = "master_accept_read_requests"
        elif key == "nodeIds":
            suggest = "node_ids"
        elif key == "readWriteMode":
            suggest = "read_write_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceEndpoint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 addresses: Optional[Sequence['outputs.InstanceEndpointAddress']] = None,
                 auto_add_new_nodes: Optional[builtins.bool] = None,
                 consist_level: Optional[builtins.str] = None,
                 consist_timeout: Optional[builtins.int] = None,
                 consist_timeout_action: Optional[builtins.str] = None,
                 description: Optional[builtins.str] = None,
                 distributed_transaction: Optional[builtins.bool] = None,
                 endpoint_id: Optional[builtins.str] = None,
                 endpoint_name: Optional[builtins.str] = None,
                 endpoint_type: Optional[builtins.str] = None,
                 master_accept_read_requests: Optional[builtins.bool] = None,
                 node_ids: Optional[Sequence[builtins.str]] = None,
                 read_write_mode: Optional[builtins.str] = None):
        """
        :param builtins.bool auto_add_new_nodes: 是否允许自动加入新节点，取值：true：是。false：否。
        :param builtins.str consist_level: 一致性级别，仅对读写模式的连接终端有效。取值：Eventual：最终一致性。Session：会话一致性。Global：全局一致性。
        :param builtins.int consist_timeout: 延迟很大时，只读节点同步最新数据的超时时间，单位为 us，取值范围为 1us~100000000us。
        :param builtins.str consist_timeout_action: 只读节点同步数据超时后的超时策略，支持以下两种策略：ReturnError：返回 SQL 报错（wait replication complete timeout, please retry）。ReadMaster：发送请求到主节点。
        :param builtins.str description: 地址描述。
        :param builtins.bool distributed_transaction: 是否开启事务拆分，仅对读写模式的连接终端有效。取值：true：是。false：否。
        :param builtins.str endpoint_id: 实例连接终端 ID。
        :param builtins.str endpoint_name: 实例连接终端名称。
        :param builtins.str endpoint_type: 连接终端类型，取值：Cluster：默认终端。Primary：主节点终端。Custom：自定义终端。
        :param builtins.bool master_accept_read_requests: 主节点是否接受读请求。仅对读写模式的连接终端有效。true：是。false：否。
        :param Sequence[builtins.str] node_ids: 连接终端配置的节点列表。
        :param builtins.str read_write_mode: 连接终端的读写模式，取值：ReadWrite: 读写。ReadOnly: 只读。
        """
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)
        if auto_add_new_nodes is not None:
            pulumi.set(__self__, "auto_add_new_nodes", auto_add_new_nodes)
        if consist_level is not None:
            pulumi.set(__self__, "consist_level", consist_level)
        if consist_timeout is not None:
            pulumi.set(__self__, "consist_timeout", consist_timeout)
        if consist_timeout_action is not None:
            pulumi.set(__self__, "consist_timeout_action", consist_timeout_action)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if distributed_transaction is not None:
            pulumi.set(__self__, "distributed_transaction", distributed_transaction)
        if endpoint_id is not None:
            pulumi.set(__self__, "endpoint_id", endpoint_id)
        if endpoint_name is not None:
            pulumi.set(__self__, "endpoint_name", endpoint_name)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if master_accept_read_requests is not None:
            pulumi.set(__self__, "master_accept_read_requests", master_accept_read_requests)
        if node_ids is not None:
            pulumi.set(__self__, "node_ids", node_ids)
        if read_write_mode is not None:
            pulumi.set(__self__, "read_write_mode", read_write_mode)

    @property
    @pulumi.getter
    def addresses(self) -> Optional[Sequence['outputs.InstanceEndpointAddress']]:
        return pulumi.get(self, "addresses")

    @property
    @pulumi.getter(name="autoAddNewNodes")
    def auto_add_new_nodes(self) -> Optional[builtins.bool]:
        """
        是否允许自动加入新节点，取值：true：是。false：否。
        """
        return pulumi.get(self, "auto_add_new_nodes")

    @property
    @pulumi.getter(name="consistLevel")
    def consist_level(self) -> Optional[builtins.str]:
        """
        一致性级别，仅对读写模式的连接终端有效。取值：Eventual：最终一致性。Session：会话一致性。Global：全局一致性。
        """
        return pulumi.get(self, "consist_level")

    @property
    @pulumi.getter(name="consistTimeout")
    def consist_timeout(self) -> Optional[builtins.int]:
        """
        延迟很大时，只读节点同步最新数据的超时时间，单位为 us，取值范围为 1us~100000000us。
        """
        return pulumi.get(self, "consist_timeout")

    @property
    @pulumi.getter(name="consistTimeoutAction")
    def consist_timeout_action(self) -> Optional[builtins.str]:
        """
        只读节点同步数据超时后的超时策略，支持以下两种策略：ReturnError：返回 SQL 报错（wait replication complete timeout, please retry）。ReadMaster：发送请求到主节点。
        """
        return pulumi.get(self, "consist_timeout_action")

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        地址描述。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="distributedTransaction")
    def distributed_transaction(self) -> Optional[builtins.bool]:
        """
        是否开启事务拆分，仅对读写模式的连接终端有效。取值：true：是。false：否。
        """
        return pulumi.get(self, "distributed_transaction")

    @property
    @pulumi.getter(name="endpointId")
    def endpoint_id(self) -> Optional[builtins.str]:
        """
        实例连接终端 ID。
        """
        return pulumi.get(self, "endpoint_id")

    @property
    @pulumi.getter(name="endpointName")
    def endpoint_name(self) -> Optional[builtins.str]:
        """
        实例连接终端名称。
        """
        return pulumi.get(self, "endpoint_name")

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[builtins.str]:
        """
        连接终端类型，取值：Cluster：默认终端。Primary：主节点终端。Custom：自定义终端。
        """
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter(name="masterAcceptReadRequests")
    def master_accept_read_requests(self) -> Optional[builtins.bool]:
        """
        主节点是否接受读请求。仅对读写模式的连接终端有效。true：是。false：否。
        """
        return pulumi.get(self, "master_accept_read_requests")

    @property
    @pulumi.getter(name="nodeIds")
    def node_ids(self) -> Optional[Sequence[builtins.str]]:
        """
        连接终端配置的节点列表。
        """
        return pulumi.get(self, "node_ids")

    @property
    @pulumi.getter(name="readWriteMode")
    def read_write_mode(self) -> Optional[builtins.str]:
        """
        连接终端的读写模式，取值：ReadWrite: 读写。ReadOnly: 只读。
        """
        return pulumi.get(self, "read_write_mode")


@pulumi.output_type
class InstanceEndpointAddress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dnsVisibility":
            suggest = "dns_visibility"
        elif key == "eipId":
            suggest = "eip_id"
        elif key == "ipAddress":
            suggest = "ip_address"
        elif key == "networkType":
            suggest = "network_type"
        elif key == "subnetId":
            suggest = "subnet_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceEndpointAddress. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceEndpointAddress.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceEndpointAddress.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dns_visibility: Optional[builtins.bool] = None,
                 domain: Optional[builtins.str] = None,
                 eip_id: Optional[builtins.str] = None,
                 ip_address: Optional[builtins.str] = None,
                 network_type: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 subnet_id: Optional[builtins.str] = None):
        """
        :param builtins.bool dns_visibility: 解析方式。当前返回值只能为 false。
        :param builtins.str domain: 实例内网访问域名。
        :param builtins.str eip_id: 公网 ID。
        :param builtins.str ip_address: IP 地址。
        :param builtins.str network_type: 网络类型：Private：私有网络 VPC。Public：公网访问。
        :param builtins.str port: 实例内网访问端口。
        :param builtins.str subnet_id: 子网 ID。子网必须属于所选的可用区。
        """
        if dns_visibility is not None:
            pulumi.set(__self__, "dns_visibility", dns_visibility)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if eip_id is not None:
            pulumi.set(__self__, "eip_id", eip_id)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if network_type is not None:
            pulumi.set(__self__, "network_type", network_type)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="dnsVisibility")
    def dns_visibility(self) -> Optional[builtins.bool]:
        """
        解析方式。当前返回值只能为 false。
        """
        return pulumi.get(self, "dns_visibility")

    @property
    @pulumi.getter
    def domain(self) -> Optional[builtins.str]:
        """
        实例内网访问域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="eipId")
    def eip_id(self) -> Optional[builtins.str]:
        """
        公网 ID。
        """
        return pulumi.get(self, "eip_id")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[builtins.str]:
        """
        IP 地址。
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> Optional[builtins.str]:
        """
        网络类型：Private：私有网络 VPC。Public：公网访问。
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.str]:
        """
        实例内网访问端口。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[builtins.str]:
        """
        子网 ID。子网必须属于所选的可用区。
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class InstanceMaintenanceWindow(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dayKind":
            suggest = "day_kind"
        elif key == "dayOfMonths":
            suggest = "day_of_months"
        elif key == "dayOfWeeks":
            suggest = "day_of_weeks"
        elif key == "maintenanceTime":
            suggest = "maintenance_time"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceMaintenanceWindow. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceMaintenanceWindow.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceMaintenanceWindow.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 day_kind: Optional[builtins.str] = None,
                 day_of_months: Optional[Sequence[builtins.int]] = None,
                 day_of_weeks: Optional[Sequence[builtins.str]] = None,
                 maintenance_time: Optional[builtins.str] = None):
        """
        :param builtins.str day_kind: 可维护周期粒度，默认取值为：Week（周）。
        :param Sequence[builtins.int] day_of_months: 指定每月哪一天为可维护时间段，默认为空，表示每天都指定。
        :param Sequence[builtins.str] day_of_weeks: 每周的哪一天为可维护时间段，默认取值为每一天：Monday，Tuesday，Wednesday，Thursday，Friday，Saturday，Sunday。
        :param builtins.str maintenance_time: 实例的可维护时间段。格式：HH:mmZ-HH:mmZ（UTC 时间）。
        """
        if day_kind is not None:
            pulumi.set(__self__, "day_kind", day_kind)
        if day_of_months is not None:
            pulumi.set(__self__, "day_of_months", day_of_months)
        if day_of_weeks is not None:
            pulumi.set(__self__, "day_of_weeks", day_of_weeks)
        if maintenance_time is not None:
            pulumi.set(__self__, "maintenance_time", maintenance_time)

    @property
    @pulumi.getter(name="dayKind")
    def day_kind(self) -> Optional[builtins.str]:
        """
        可维护周期粒度，默认取值为：Week（周）。
        """
        return pulumi.get(self, "day_kind")

    @property
    @pulumi.getter(name="dayOfMonths")
    def day_of_months(self) -> Optional[Sequence[builtins.int]]:
        """
        指定每月哪一天为可维护时间段，默认为空，表示每天都指定。
        """
        return pulumi.get(self, "day_of_months")

    @property
    @pulumi.getter(name="dayOfWeeks")
    def day_of_weeks(self) -> Optional[Sequence[builtins.str]]:
        """
        每周的哪一天为可维护时间段，默认取值为每一天：Monday，Tuesday，Wednesday，Thursday，Friday，Saturday，Sunday。
        """
        return pulumi.get(self, "day_of_weeks")

    @property
    @pulumi.getter(name="maintenanceTime")
    def maintenance_time(self) -> Optional[builtins.str]:
        """
        实例的可维护时间段。格式：HH:mmZ-HH:mmZ（UTC 时间）。
        """
        return pulumi.get(self, "maintenance_time")


@pulumi.output_type
class InstanceNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failoverPriority":
            suggest = "failover_priority"
        elif key == "nodeType":
            suggest = "node_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in InstanceNode. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        InstanceNode.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        InstanceNode.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 failover_priority: Optional[builtins.int] = None,
                 node_type: Optional[builtins.str] = None):
        """
        :param builtins.int failover_priority: 节点切主的优先级，取值范围为 0~15。数值越大，优先级越高。
        :param builtins.str node_type: 节点类型。取值：Primary：主节点。ReadOnly：只读节点。
        """
        if failover_priority is not None:
            pulumi.set(__self__, "failover_priority", failover_priority)
        if node_type is not None:
            pulumi.set(__self__, "node_type", node_type)

    @property
    @pulumi.getter(name="failoverPriority")
    def failover_priority(self) -> Optional[builtins.int]:
        """
        节点切主的优先级，取值范围为 0~15。数值越大，优先级越高。
        """
        return pulumi.get(self, "failover_priority")

    @property
    @pulumi.getter(name="nodeType")
    def node_type(self) -> Optional[builtins.str]:
        """
        节点类型。取值：Primary：主节点。ReadOnly：只读节点。
        """
        return pulumi.get(self, "node_type")


@pulumi.output_type
class InstanceTag(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: 用户标签的标签键。长度取值范围为1~128字符，允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。若标签键开头或结尾存在空格，系统会自动为其去除。
        :param builtins.str value: 用户标签的标签值。允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。大小写敏感。若标签值开头或结尾存在空格，系统会自动为其去除。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        用户标签的标签键。长度取值范围为1~128字符，允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。若标签键开头或结尾存在空格，系统会自动为其去除。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        用户标签的标签值。允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。大小写敏感。若标签值开头或结尾存在空格，系统会自动为其去除。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetInstanceChargeDetailResult(dict):
    def __init__(__self__, *,
                 auto_renew: builtins.bool,
                 charge_end_time: builtins.str,
                 charge_start_time: builtins.str,
                 charge_status: builtins.str,
                 charge_type: builtins.str,
                 overdue_reclaim_time: builtins.str,
                 overdue_time: builtins.str,
                 period: builtins.int,
                 period_unit: builtins.str):
        """
        :param builtins.bool auto_renew: 预付费场景下是否自动续费。取值：true：自动续费。false：不自动续费。
        :param builtins.str charge_end_time: 预付费场景下计费到期的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.str charge_start_time: 计费开始的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.str charge_status: 付费状态：Normal：正常。Overdue：欠费。Shutdown：关停。
        :param builtins.str charge_type: 计费类型。PostPaid：按量计费；PrePaid：包年包月。
        :param builtins.str overdue_reclaim_time: 欠费关停时预计释放时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.str overdue_time: 欠费关停时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        :param builtins.int period: 预付费场景下的购买时长。
        :param builtins.str period_unit: 预付费场景下的购买周期。Month：包月。Year：包年。
        """
        pulumi.set(__self__, "auto_renew", auto_renew)
        pulumi.set(__self__, "charge_end_time", charge_end_time)
        pulumi.set(__self__, "charge_start_time", charge_start_time)
        pulumi.set(__self__, "charge_status", charge_status)
        pulumi.set(__self__, "charge_type", charge_type)
        pulumi.set(__self__, "overdue_reclaim_time", overdue_reclaim_time)
        pulumi.set(__self__, "overdue_time", overdue_time)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "period_unit", period_unit)

    @property
    @pulumi.getter(name="autoRenew")
    def auto_renew(self) -> builtins.bool:
        """
        预付费场景下是否自动续费。取值：true：自动续费。false：不自动续费。
        """
        return pulumi.get(self, "auto_renew")

    @property
    @pulumi.getter(name="chargeEndTime")
    def charge_end_time(self) -> builtins.str:
        """
        预付费场景下计费到期的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "charge_end_time")

    @property
    @pulumi.getter(name="chargeStartTime")
    def charge_start_time(self) -> builtins.str:
        """
        计费开始的时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "charge_start_time")

    @property
    @pulumi.getter(name="chargeStatus")
    def charge_status(self) -> builtins.str:
        """
        付费状态：Normal：正常。Overdue：欠费。Shutdown：关停。
        """
        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="overdueReclaimTime")
    def overdue_reclaim_time(self) -> builtins.str:
        """
        欠费关停时预计释放时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "overdue_reclaim_time")

    @property
    @pulumi.getter(name="overdueTime")
    def overdue_time(self) -> builtins.str:
        """
        欠费关停时间，格式：yyyy-MM-ddTHH:mm:ssZ（UTC 时间）。
        """
        return pulumi.get(self, "overdue_time")

    @property
    @pulumi.getter
    def period(self) -> builtins.int:
        """
        预付费场景下的购买时长。
        """
        return pulumi.get(self, "period")

    @property
    @pulumi.getter(name="periodUnit")
    def period_unit(self) -> builtins.str:
        """
        预付费场景下的购买周期。Month：包月。Year：包年。
        """
        return pulumi.get(self, "period_unit")


@pulumi.output_type
class GetInstanceEndpointResult(dict):
    def __init__(__self__, *,
                 addresses: Sequence['outputs.GetInstanceEndpointAddressResult'],
                 auto_add_new_nodes: builtins.bool,
                 consist_level: builtins.str,
                 consist_timeout: builtins.int,
                 consist_timeout_action: builtins.str,
                 description: builtins.str,
                 distributed_transaction: builtins.bool,
                 endpoint_id: builtins.str,
                 endpoint_name: builtins.str,
                 endpoint_type: builtins.str,
                 master_accept_read_requests: builtins.bool,
                 node_ids: Sequence[builtins.str],
                 read_write_mode: builtins.str):
        """
        :param Sequence['GetInstanceEndpointAddressArgs'] addresses: 连接地址信息。
        :param builtins.bool auto_add_new_nodes: 是否允许自动加入新节点，取值：true：是。false：否。
        :param builtins.str consist_level: 一致性级别，仅对读写模式的连接终端有效。取值：Eventual：最终一致性。Session：会话一致性。Global：全局一致性。
        :param builtins.int consist_timeout: 延迟很大时，只读节点同步最新数据的超时时间，单位为 us，取值范围为 1us~100000000us。
        :param builtins.str consist_timeout_action: 只读节点同步数据超时后的超时策略，支持以下两种策略：ReturnError：返回 SQL 报错（wait replication complete timeout, please retry）。ReadMaster：发送请求到主节点。
        :param builtins.str description: 地址描述。
        :param builtins.bool distributed_transaction: 是否开启事务拆分，仅对读写模式的连接终端有效。取值：true：是。false：否。
        :param builtins.str endpoint_id: 实例连接终端 ID。
        :param builtins.str endpoint_name: 实例连接终端名称。
        :param builtins.str endpoint_type: 连接终端类型，取值：Cluster：默认终端。Primary：主节点终端。Custom：自定义终端。
        :param builtins.bool master_accept_read_requests: 主节点是否接受读请求。仅对读写模式的连接终端有效。true：是。false：否。
        :param Sequence[builtins.str] node_ids: 连接终端配置的节点列表。
        :param builtins.str read_write_mode: 连接终端的读写模式，取值：ReadWrite: 读写。ReadOnly: 只读。
        """
        pulumi.set(__self__, "addresses", addresses)
        pulumi.set(__self__, "auto_add_new_nodes", auto_add_new_nodes)
        pulumi.set(__self__, "consist_level", consist_level)
        pulumi.set(__self__, "consist_timeout", consist_timeout)
        pulumi.set(__self__, "consist_timeout_action", consist_timeout_action)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "distributed_transaction", distributed_transaction)
        pulumi.set(__self__, "endpoint_id", endpoint_id)
        pulumi.set(__self__, "endpoint_name", endpoint_name)
        pulumi.set(__self__, "endpoint_type", endpoint_type)
        pulumi.set(__self__, "master_accept_read_requests", master_accept_read_requests)
        pulumi.set(__self__, "node_ids", node_ids)
        pulumi.set(__self__, "read_write_mode", read_write_mode)

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

    @property
    @pulumi.getter(name="autoAddNewNodes")
    def auto_add_new_nodes(self) -> builtins.bool:
        """
        是否允许自动加入新节点，取值：true：是。false：否。
        """
        return pulumi.get(self, "auto_add_new_nodes")

    @property
    @pulumi.getter(name="consistLevel")
    def consist_level(self) -> builtins.str:
        """
        一致性级别，仅对读写模式的连接终端有效。取值：Eventual：最终一致性。Session：会话一致性。Global：全局一致性。
        """
        return pulumi.get(self, "consist_level")

    @property
    @pulumi.getter(name="consistTimeout")
    def consist_timeout(self) -> builtins.int:
        """
        延迟很大时，只读节点同步最新数据的超时时间，单位为 us，取值范围为 1us~100000000us。
        """
        return pulumi.get(self, "consist_timeout")

    @property
    @pulumi.getter(name="consistTimeoutAction")
    def consist_timeout_action(self) -> builtins.str:
        """
        只读节点同步数据超时后的超时策略，支持以下两种策略：ReturnError：返回 SQL 报错（wait replication complete timeout, please retry）。ReadMaster：发送请求到主节点。
        """
        return pulumi.get(self, "consist_timeout_action")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        地址描述。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="distributedTransaction")
    def distributed_transaction(self) -> builtins.bool:
        """
        是否开启事务拆分，仅对读写模式的连接终端有效。取值：true：是。false：否。
        """
        return pulumi.get(self, "distributed_transaction")

    @property
    @pulumi.getter(name="endpointId")
    def endpoint_id(self) -> builtins.str:
        """
        实例连接终端 ID。
        """
        return pulumi.get(self, "endpoint_id")

    @property
    @pulumi.getter(name="endpointName")
    def endpoint_name(self) -> builtins.str:
        """
        实例连接终端名称。
        """
        return pulumi.get(self, "endpoint_name")

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> builtins.str:
        """
        连接终端类型，取值：Cluster：默认终端。Primary：主节点终端。Custom：自定义终端。
        """
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter(name="masterAcceptReadRequests")
    def master_accept_read_requests(self) -> builtins.bool:
        """
        主节点是否接受读请求。仅对读写模式的连接终端有效。true：是。false：否。
        """
        return pulumi.get(self, "master_accept_read_requests")

    @property
    @pulumi.getter(name="nodeIds")
    def node_ids(self) -> Sequence[builtins.str]:
        """
        连接终端配置的节点列表。
        """
        return pulumi.get(self, "node_ids")

    @property
    @pulumi.getter(name="readWriteMode")
    def read_write_mode(self) -> builtins.str:
        """
        连接终端的读写模式，取值：ReadWrite: 读写。ReadOnly: 只读。
        """
        return pulumi.get(self, "read_write_mode")


@pulumi.output_type
class GetInstanceEndpointAddressResult(dict):
    def __init__(__self__, *,
                 dns_visibility: builtins.bool,
                 domain: builtins.str,
                 eip_id: builtins.str,
                 ip_address: builtins.str,
                 network_type: builtins.str,
                 port: builtins.str,
                 subnet_id: builtins.str):
        """
        :param builtins.bool dns_visibility: 解析方式。当前返回值只能为 false。
        :param builtins.str domain: 实例内网访问域名。
        :param builtins.str eip_id: 公网 ID。
        :param builtins.str ip_address: IP 地址。
        :param builtins.str network_type: 网络类型：Private：私有网络 VPC。Public：公网访问。
        :param builtins.str port: 实例内网访问端口。
        :param builtins.str subnet_id: 子网 ID。子网必须属于所选的可用区。
        """
        pulumi.set(__self__, "dns_visibility", dns_visibility)
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "eip_id", eip_id)
        pulumi.set(__self__, "ip_address", ip_address)
        pulumi.set(__self__, "network_type", network_type)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="dnsVisibility")
    def dns_visibility(self) -> builtins.bool:
        """
        解析方式。当前返回值只能为 false。
        """
        return pulumi.get(self, "dns_visibility")

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        实例内网访问域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="eipId")
    def eip_id(self) -> builtins.str:
        """
        公网 ID。
        """
        return pulumi.get(self, "eip_id")

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> builtins.str:
        """
        IP 地址。
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> builtins.str:
        """
        网络类型：Private：私有网络 VPC。Public：公网访问。
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter
    def port(self) -> builtins.str:
        """
        实例内网访问端口。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        子网 ID。子网必须属于所选的可用区。
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class GetInstanceMaintenanceWindowResult(dict):
    def __init__(__self__, *,
                 day_kind: builtins.str,
                 day_of_months: Sequence[builtins.int],
                 day_of_weeks: Sequence[builtins.str],
                 maintenance_time: builtins.str):
        """
        :param builtins.str day_kind: 可维护周期粒度，默认取值为：Week（周）。
        :param Sequence[builtins.int] day_of_months: 指定每月哪一天为可维护时间段，默认为空，表示每天都指定。
        :param Sequence[builtins.str] day_of_weeks: 每周的哪一天为可维护时间段，默认取值为每一天：Monday，Tuesday，Wednesday，Thursday，Friday，Saturday，Sunday。
        :param builtins.str maintenance_time: 实例的可维护时间段。格式：HH:mmZ-HH:mmZ（UTC 时间）。
        """
        pulumi.set(__self__, "day_kind", day_kind)
        pulumi.set(__self__, "day_of_months", day_of_months)
        pulumi.set(__self__, "day_of_weeks", day_of_weeks)
        pulumi.set(__self__, "maintenance_time", maintenance_time)

    @property
    @pulumi.getter(name="dayKind")
    def day_kind(self) -> builtins.str:
        """
        可维护周期粒度，默认取值为：Week（周）。
        """
        return pulumi.get(self, "day_kind")

    @property
    @pulumi.getter(name="dayOfMonths")
    def day_of_months(self) -> Sequence[builtins.int]:
        """
        指定每月哪一天为可维护时间段，默认为空，表示每天都指定。
        """
        return pulumi.get(self, "day_of_months")

    @property
    @pulumi.getter(name="dayOfWeeks")
    def day_of_weeks(self) -> Sequence[builtins.str]:
        """
        每周的哪一天为可维护时间段，默认取值为每一天：Monday，Tuesday，Wednesday，Thursday，Friday，Saturday，Sunday。
        """
        return pulumi.get(self, "day_of_weeks")

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


@pulumi.output_type
class GetInstanceNodeResult(dict):
    def __init__(__self__, *,
                 failover_priority: builtins.int,
                 memory: builtins.int,
                 node_id: builtins.str,
                 node_spec: builtins.str,
                 node_type: builtins.str,
                 v_cpu: builtins.int,
                 zone_id: builtins.str):
        """
        :param builtins.int failover_priority: 节点切主的优先级，取值范围为 0~15。数值越大，优先级越高。
        :param builtins.int memory: 内存大小，单位为 GiB。
        :param builtins.str node_id: 节点 ID。
        :param builtins.str node_spec: 节点规格。
        :param builtins.str node_type: 节点类型。取值：Primary：主节点。ReadOnly：只读节点。
        :param builtins.int v_cpu: CPU 大小，例如当取值为 1 时表示 CPU 大小为 1U。
        :param builtins.str zone_id: 可用区 ID。
        """
        pulumi.set(__self__, "failover_priority", failover_priority)
        pulumi.set(__self__, "memory", memory)
        pulumi.set(__self__, "node_id", node_id)
        pulumi.set(__self__, "node_spec", node_spec)
        pulumi.set(__self__, "node_type", node_type)
        pulumi.set(__self__, "v_cpu", v_cpu)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="failoverPriority")
    def failover_priority(self) -> builtins.int:
        """
        节点切主的优先级，取值范围为 0~15。数值越大，优先级越高。
        """
        return pulumi.get(self, "failover_priority")

    @property
    @pulumi.getter
    def memory(self) -> builtins.int:
        """
        内存大小，单位为 GiB。
        """
        return pulumi.get(self, "memory")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> builtins.str:
        """
        节点 ID。
        """
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter(name="nodeSpec")
    def node_spec(self) -> builtins.str:
        """
        节点规格。
        """
        return pulumi.get(self, "node_spec")

    @property
    @pulumi.getter(name="nodeType")
    def node_type(self) -> builtins.str:
        """
        节点类型。取值：Primary：主节点。ReadOnly：只读节点。
        """
        return pulumi.get(self, "node_type")

    @property
    @pulumi.getter(name="vCpu")
    def v_cpu(self) -> builtins.int:
        """
        CPU 大小，例如当取值为 1 时表示 CPU 大小为 1U。
        """
        return pulumi.get(self, "v_cpu")

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


@pulumi.output_type
class GetInstanceTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 用户标签的标签键。长度取值范围为1~128字符，允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。若标签键开头或结尾存在空格，系统会自动为其去除。
        :param builtins.str value: 用户标签的标签值。允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。大小写敏感。若标签值开头或结尾存在空格，系统会自动为其去除。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        用户标签的标签键。长度取值范围为1~128字符，允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。若标签键开头或结尾存在空格，系统会自动为其去除。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        用户标签的标签值。允许输入各国语言文字、数字、空格（ ）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、中划线（-）和@（@）。大小写敏感。若标签值开头或结尾存在空格，系统会自动为其去除。
        """
        return pulumi.get(self, "value")


