# 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

__all__ = [
    'InstanceChargeDetailArgs',
    'InstanceChargeDetailArgsDict',
    'InstanceEndpointArgs',
    'InstanceEndpointArgsDict',
    'InstanceEndpointAddressArgs',
    'InstanceEndpointAddressArgsDict',
    'InstanceMaintenanceWindowArgs',
    'InstanceMaintenanceWindowArgsDict',
    'InstanceNodeArgs',
    'InstanceNodeArgsDict',
    'InstanceTagArgs',
    'InstanceTagArgsDict',
]

MYPY = False

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class InstanceEndpointAddressArgsDict(TypedDict):
        dns_visibility: NotRequired[pulumi.Input[builtins.bool]]
        """
        解析方式。当前返回值只能为 false。
        """
        domain: NotRequired[pulumi.Input[builtins.str]]
        """
        实例内网访问域名。
        """
        eip_id: NotRequired[pulumi.Input[builtins.str]]
        """
        公网 ID。
        """
        ip_address: NotRequired[pulumi.Input[builtins.str]]
        """
        IP 地址。
        """
        network_type: NotRequired[pulumi.Input[builtins.str]]
        """
        网络类型：Private：私有网络 VPC。Public：公网访问。
        """
        port: NotRequired[pulumi.Input[builtins.str]]
        """
        实例内网访问端口。
        """
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        子网 ID。子网必须属于所选的可用区。
        """
elif False:
    InstanceEndpointAddressArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceEndpointAddressArgs:
    def __init__(__self__, *,
                 dns_visibility: Optional[pulumi.Input[builtins.bool]] = None,
                 domain: Optional[pulumi.Input[builtins.str]] = None,
                 eip_id: Optional[pulumi.Input[builtins.str]] = None,
                 ip_address: Optional[pulumi.Input[builtins.str]] = None,
                 network_type: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.str]] = None,
                 subnet_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.bool] dns_visibility: 解析方式。当前返回值只能为 false。
        :param pulumi.Input[builtins.str] domain: 实例内网访问域名。
        :param pulumi.Input[builtins.str] eip_id: 公网 ID。
        :param pulumi.Input[builtins.str] ip_address: IP 地址。
        :param pulumi.Input[builtins.str] network_type: 网络类型：Private：私有网络 VPC。Public：公网访问。
        :param pulumi.Input[builtins.str] port: 实例内网访问端口。
        :param pulumi.Input[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[pulumi.Input[builtins.bool]]:
        """
        解析方式。当前返回值只能为 false。
        """
        return pulumi.get(self, "dns_visibility")

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

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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class InstanceMaintenanceWindowArgsDict(TypedDict):
        day_kind: NotRequired[pulumi.Input[builtins.str]]
        """
        可维护周期粒度，默认取值为：Week（周）。
        """
        day_of_months: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]
        """
        指定每月哪一天为可维护时间段，默认为空，表示每天都指定。
        """
        day_of_weeks: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        每周的哪一天为可维护时间段，默认取值为每一天：Monday，Tuesday，Wednesday，Thursday，Friday，Saturday，Sunday。
        """
        maintenance_time: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的可维护时间段。格式：HH:mmZ-HH:mmZ（UTC 时间）。
        """
elif False:
    InstanceMaintenanceWindowArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceMaintenanceWindowArgs:
    def __init__(__self__, *,
                 day_kind: Optional[pulumi.Input[builtins.str]] = None,
                 day_of_months: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]] = None,
                 day_of_weeks: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 maintenance_time: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] day_kind: 可维护周期粒度，默认取值为：Week（周）。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.int]]] day_of_months: 指定每月哪一天为可维护时间段，默认为空，表示每天都指定。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] day_of_weeks: 每周的哪一天为可维护时间段，默认取值为每一天：Monday，Tuesday，Wednesday，Thursday，Friday，Saturday，Sunday。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        可维护周期粒度，默认取值为：Week（周）。
        """
        return pulumi.get(self, "day_kind")

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

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

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

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

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

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

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


if not MYPY:
    class InstanceNodeArgsDict(TypedDict):
        failover_priority: NotRequired[pulumi.Input[builtins.int]]
        """
        节点切主的优先级，取值范围为 0~15。数值越大，优先级越高。
        """
        node_type: NotRequired[pulumi.Input[builtins.str]]
        """
        节点类型。取值：Primary：主节点。ReadOnly：只读节点。
        """
elif False:
    InstanceNodeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceNodeArgs:
    def __init__(__self__, *,
                 failover_priority: Optional[pulumi.Input[builtins.int]] = None,
                 node_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] failover_priority: 节点切主的优先级，取值范围为 0~15。数值越大，优先级越高。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        节点切主的优先级，取值范围为 0~15。数值越大，优先级越高。
        """
        return pulumi.get(self, "failover_priority")

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

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

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


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

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

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

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

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


