# 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__ = [
    'DbAccountAccountPrivilegeArgs',
    'DbAccountAccountPrivilegeArgsDict',
    'DbAccountTableColumnPrivilegeArgs',
    'DbAccountTableColumnPrivilegeArgsDict',
    'DbAccountTableColumnPrivilegeColumnPrivilegeArgs',
    'DbAccountTableColumnPrivilegeColumnPrivilegeArgsDict',
    'DbAccountTableColumnPrivilegeTablePrivilegeArgs',
    'DbAccountTableColumnPrivilegeTablePrivilegeArgsDict',
    'InstanceAddressObjectArgs',
    'InstanceAddressObjectArgsDict',
    'InstanceAutoStorageScalingConfigArgs',
    'InstanceAutoStorageScalingConfigArgsDict',
    'InstanceChargeDetailArgs',
    'InstanceChargeDetailArgsDict',
    'InstanceDisasterRecoveryInstanceArgs',
    'InstanceDisasterRecoveryInstanceArgsDict',
    'InstanceEndpointArgs',
    'InstanceEndpointArgsDict',
    'InstanceEndpointReadOnlyNodeWeightArgs',
    'InstanceEndpointReadOnlyNodeWeightArgsDict',
    'InstanceMaintenanceWindowArgs',
    'InstanceMaintenanceWindowArgsDict',
    'InstanceNodeArgs',
    'InstanceNodeArgsDict',
    'InstanceProxyDetailArgs',
    'InstanceProxyDetailArgsDict',
    'InstanceProxyDetailProxyResourceInfoArgs',
    'InstanceProxyDetailProxyResourceInfoArgsDict',
    'InstanceTagArgs',
    'InstanceTagArgsDict',
]

MYPY = False

if not MYPY:
    class DbAccountAccountPrivilegeArgsDict(TypedDict):
        account_privilege: NotRequired[pulumi.Input[builtins.str]]
        """
        数据库权限的类型。取值范围：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。Global：全局权限。None：清除账号权限。说明该参数作为请求参数时，有以下注意事项：仅支持在作为请求参数时允许取值为 Global 和 None。权限类型为单选，传多个时会报错。仅 GrantDBAccountPrivilege 接口支持为 AccountPrivilege 取值 None。当 AccountPrivilege 取值 None 时，如果 DBName 的取值为空字符串，则清除账号的所有全局权限。如果 DBName 的取值为指定数据库，则清除账号在该数据库的所有权限。
        """
        account_privilege_details: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        账号的权限信息。当 AccountPrivilege 取值为 Custom 时，该字段的取值范围如下：SELECT INSERT UPDATE DELETE CREATE DROP REFERENCES INDEX ALTER CREATE TEMPORARY TABLES LOCK TABLES EXECUTE CREATE VIEW SHOW VIEW EVENT TRIGGER CREATE ROUTINE ALTER ROUTINE 当 AccountPrivilege 取值为 Global 时，该字段的取值范围如下：PROCESS REPLICATION SLAVE REPLICATION CLIENT SELECT INSERT UPDATE DELETE CREATE DROP RELOAD REFERENCES INDEX ALTER LOCK TABLES EXECUTE CREATE VIEW SHOW VIEW CREATE ROUTINE ALTER ROUTINE CREATE USER EVENT TRIGGER SHOW DATABASES CREATE TEMPORARY TABLES 说明  作为请求参数时，在 AccountPrivilege 取值为 Custom 时必填。 在 CreateDBAccount 接口中，会自动为账号赋予 REPLICATION SLAVE、PROCESS 和 REPLICATION CLIENT 全局权限。 可取多个值。使用英文逗号（,）分隔多个权限。写入方式为覆盖方式。
        """
        db_name: NotRequired[pulumi.Input[builtins.str]]
        """
        需修改账号授权的或账号已有权限的数据库名称。说明在 CreateDBAccount 和 GrantDBAccountPrivilege 接口中作为请求参数时，需确认 DBName 对应的数据库已存在。进行全局授权的修改时，应为 DBName 传空字符。
        """
elif False:
    DbAccountAccountPrivilegeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DbAccountAccountPrivilegeArgs:
    def __init__(__self__, *,
                 account_privilege: Optional[pulumi.Input[builtins.str]] = None,
                 account_privilege_details: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 db_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] account_privilege: 数据库权限的类型。取值范围：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。Global：全局权限。None：清除账号权限。说明该参数作为请求参数时，有以下注意事项：仅支持在作为请求参数时允许取值为 Global 和 None。权限类型为单选，传多个时会报错。仅 GrantDBAccountPrivilege 接口支持为 AccountPrivilege 取值 None。当 AccountPrivilege 取值 None 时，如果 DBName 的取值为空字符串，则清除账号的所有全局权限。如果 DBName 的取值为指定数据库，则清除账号在该数据库的所有权限。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] account_privilege_details: 账号的权限信息。当 AccountPrivilege 取值为 Custom 时，该字段的取值范围如下：SELECT INSERT UPDATE DELETE CREATE DROP REFERENCES INDEX ALTER CREATE TEMPORARY TABLES LOCK TABLES EXECUTE CREATE VIEW SHOW VIEW EVENT TRIGGER CREATE ROUTINE ALTER ROUTINE 当 AccountPrivilege 取值为 Global 时，该字段的取值范围如下：PROCESS REPLICATION SLAVE REPLICATION CLIENT SELECT INSERT UPDATE DELETE CREATE DROP RELOAD REFERENCES INDEX ALTER LOCK TABLES EXECUTE CREATE VIEW SHOW VIEW CREATE ROUTINE ALTER ROUTINE CREATE USER EVENT TRIGGER SHOW DATABASES CREATE TEMPORARY TABLES 说明  作为请求参数时，在 AccountPrivilege 取值为 Custom 时必填。 在 CreateDBAccount 接口中，会自动为账号赋予 REPLICATION SLAVE、PROCESS 和 REPLICATION CLIENT 全局权限。 可取多个值。使用英文逗号（,）分隔多个权限。写入方式为覆盖方式。
        :param pulumi.Input[builtins.str] db_name: 需修改账号授权的或账号已有权限的数据库名称。说明在 CreateDBAccount 和 GrantDBAccountPrivilege 接口中作为请求参数时，需确认 DBName 对应的数据库已存在。进行全局授权的修改时，应为 DBName 传空字符。
        """
        if account_privilege is not None:
            pulumi.set(__self__, "account_privilege", account_privilege)
        if account_privilege_details is not None:
            pulumi.set(__self__, "account_privilege_details", account_privilege_details)
        if db_name is not None:
            pulumi.set(__self__, "db_name", db_name)

    @property
    @pulumi.getter(name="accountPrivilege")
    def account_privilege(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        数据库权限的类型。取值范围：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。Global：全局权限。None：清除账号权限。说明该参数作为请求参数时，有以下注意事项：仅支持在作为请求参数时允许取值为 Global 和 None。权限类型为单选，传多个时会报错。仅 GrantDBAccountPrivilege 接口支持为 AccountPrivilege 取值 None。当 AccountPrivilege 取值 None 时，如果 DBName 的取值为空字符串，则清除账号的所有全局权限。如果 DBName 的取值为指定数据库，则清除账号在该数据库的所有权限。
        """
        return pulumi.get(self, "account_privilege")

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

    @property
    @pulumi.getter(name="accountPrivilegeDetails")
    def account_privilege_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        账号的权限信息。当 AccountPrivilege 取值为 Custom 时，该字段的取值范围如下：SELECT INSERT UPDATE DELETE CREATE DROP REFERENCES INDEX ALTER CREATE TEMPORARY TABLES LOCK TABLES EXECUTE CREATE VIEW SHOW VIEW EVENT TRIGGER CREATE ROUTINE ALTER ROUTINE 当 AccountPrivilege 取值为 Global 时，该字段的取值范围如下：PROCESS REPLICATION SLAVE REPLICATION CLIENT SELECT INSERT UPDATE DELETE CREATE DROP RELOAD REFERENCES INDEX ALTER LOCK TABLES EXECUTE CREATE VIEW SHOW VIEW CREATE ROUTINE ALTER ROUTINE CREATE USER EVENT TRIGGER SHOW DATABASES CREATE TEMPORARY TABLES 说明  作为请求参数时，在 AccountPrivilege 取值为 Custom 时必填。 在 CreateDBAccount 接口中，会自动为账号赋予 REPLICATION SLAVE、PROCESS 和 REPLICATION CLIENT 全局权限。 可取多个值。使用英文逗号（,）分隔多个权限。写入方式为覆盖方式。
        """
        return pulumi.get(self, "account_privilege_details")

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

    @property
    @pulumi.getter(name="dbName")
    def db_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        需修改账号授权的或账号已有权限的数据库名称。说明在 CreateDBAccount 和 GrantDBAccountPrivilege 接口中作为请求参数时，需确认 DBName 对应的数据库已存在。进行全局授权的修改时，应为 DBName 传空字符。
        """
        return pulumi.get(self, "db_name")

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


if not MYPY:
    class DbAccountTableColumnPrivilegeArgsDict(TypedDict):
        column_privileges: NotRequired[pulumi.Input[Sequence[pulumi.Input['DbAccountTableColumnPrivilegeColumnPrivilegeArgsDict']]]]
        db_name: NotRequired[pulumi.Input[builtins.str]]
        """
        对账号进行权限设置的表所属的数据库的名称。
        """
        table_privileges: NotRequired[pulumi.Input[Sequence[pulumi.Input['DbAccountTableColumnPrivilegeTablePrivilegeArgsDict']]]]
elif False:
    DbAccountTableColumnPrivilegeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DbAccountTableColumnPrivilegeArgs:
    def __init__(__self__, *,
                 column_privileges: Optional[pulumi.Input[Sequence[pulumi.Input['DbAccountTableColumnPrivilegeColumnPrivilegeArgs']]]] = None,
                 db_name: Optional[pulumi.Input[builtins.str]] = None,
                 table_privileges: Optional[pulumi.Input[Sequence[pulumi.Input['DbAccountTableColumnPrivilegeTablePrivilegeArgs']]]] = None):
        """
        :param pulumi.Input[builtins.str] db_name: 对账号进行权限设置的表所属的数据库的名称。
        """
        if column_privileges is not None:
            pulumi.set(__self__, "column_privileges", column_privileges)
        if db_name is not None:
            pulumi.set(__self__, "db_name", db_name)
        if table_privileges is not None:
            pulumi.set(__self__, "table_privileges", table_privileges)

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

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

    @property
    @pulumi.getter(name="dbName")
    def db_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        对账号进行权限设置的表所属的数据库的名称。
        """
        return pulumi.get(self, "db_name")

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

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

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


if not MYPY:
    class DbAccountTableColumnPrivilegeColumnPrivilegeArgsDict(TypedDict):
        account_privilege_details: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        对账号进行列权限设置的权限信息。取值（可多选）：INSERT REFERENCES SELECT UPDATE说明多个权限之间使用英文逗号（,）分隔。
        """
        column_name: NotRequired[pulumi.Input[builtins.str]]
        """
        对账号进行列权限设置的列的名称。
        """
        table_name: NotRequired[pulumi.Input[builtins.str]]
        """
        对账号进行列权限设置的表所属的数据库的名称。
        """
elif False:
    DbAccountTableColumnPrivilegeColumnPrivilegeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DbAccountTableColumnPrivilegeColumnPrivilegeArgs:
    def __init__(__self__, *,
                 account_privilege_details: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 column_name: Optional[pulumi.Input[builtins.str]] = None,
                 table_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] account_privilege_details: 对账号进行列权限设置的权限信息。取值（可多选）：INSERT REFERENCES SELECT UPDATE说明多个权限之间使用英文逗号（,）分隔。
        :param pulumi.Input[builtins.str] column_name: 对账号进行列权限设置的列的名称。
        :param pulumi.Input[builtins.str] table_name: 对账号进行列权限设置的表所属的数据库的名称。
        """
        if account_privilege_details is not None:
            pulumi.set(__self__, "account_privilege_details", account_privilege_details)
        if column_name is not None:
            pulumi.set(__self__, "column_name", column_name)
        if table_name is not None:
            pulumi.set(__self__, "table_name", table_name)

    @property
    @pulumi.getter(name="accountPrivilegeDetails")
    def account_privilege_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        对账号进行列权限设置的权限信息。取值（可多选）：INSERT REFERENCES SELECT UPDATE说明多个权限之间使用英文逗号（,）分隔。
        """
        return pulumi.get(self, "account_privilege_details")

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

    @property
    @pulumi.getter(name="columnName")
    def column_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        对账号进行列权限设置的列的名称。
        """
        return pulumi.get(self, "column_name")

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

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        对账号进行列权限设置的表所属的数据库的名称。
        """
        return pulumi.get(self, "table_name")

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


if not MYPY:
    class DbAccountTableColumnPrivilegeTablePrivilegeArgsDict(TypedDict):
        account_privilege_details: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        账号的表权限。取值范围（可多选）：ALTER CREATE DELETE DROP INDEX INSERT SELECT SHOW VIEW TRIGGER UPDATE CREATE VIEW REFERENCES 说明多个权限之间使用英文逗号（,）分隔。
        """
        table_name: NotRequired[pulumi.Input[builtins.str]]
        """
        对账号进行权限设置的表的名称。
        """
elif False:
    DbAccountTableColumnPrivilegeTablePrivilegeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DbAccountTableColumnPrivilegeTablePrivilegeArgs:
    def __init__(__self__, *,
                 account_privilege_details: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 table_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] account_privilege_details: 账号的表权限。取值范围（可多选）：ALTER CREATE DELETE DROP INDEX INSERT SELECT SHOW VIEW TRIGGER UPDATE CREATE VIEW REFERENCES 说明多个权限之间使用英文逗号（,）分隔。
        :param pulumi.Input[builtins.str] table_name: 对账号进行权限设置的表的名称。
        """
        if account_privilege_details is not None:
            pulumi.set(__self__, "account_privilege_details", account_privilege_details)
        if table_name is not None:
            pulumi.set(__self__, "table_name", table_name)

    @property
    @pulumi.getter(name="accountPrivilegeDetails")
    def account_privilege_details(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        账号的表权限。取值范围（可多选）：ALTER CREATE DELETE DROP INDEX INSERT SELECT SHOW VIEW TRIGGER UPDATE CREATE VIEW REFERENCES 说明多个权限之间使用英文逗号（,）分隔。
        """
        return pulumi.get(self, "account_privilege_details")

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

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        对账号进行权限设置的表的名称。
        """
        return pulumi.get(self, "table_name")

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


if not MYPY:
    class InstanceAddressObjectArgsDict(TypedDict):
        dns_visibility: NotRequired[pulumi.Input[builtins.bool]]
        """
        false：私网解析（默认）。true：私网以及公网解析。
        """
        domain: NotRequired[pulumi.Input[builtins.str]]
        """
        连接域名。
        """
        eip_id: NotRequired[pulumi.Input[builtins.str]]
        """
        EIP 的 ID，仅对 Public 地址有效。
        """
        internet_protocol: NotRequired[pulumi.Input[builtins.str]]
        """
        IP 协议版本。取值为 IPv4。
        """
        ip_address: NotRequired[pulumi.Input[builtins.str]]
        """
        IP 地址。
        """
        network_type: NotRequired[pulumi.Input[builtins.str]]
        """
        网络地址类型，取值为：Private：私网地址。Public：公网地址。
        """
        port: NotRequired[pulumi.Input[builtins.str]]
        """
        端口。
        """
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        子网 ID，仅对 Private 地址有效。
        """
elif False:
    InstanceAddressObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceAddressObjectArgs:
    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,
                 internet_protocol: 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：私网解析（默认）。true：私网以及公网解析。
        :param pulumi.Input[builtins.str] domain: 连接域名。
        :param pulumi.Input[builtins.str] eip_id: EIP 的 ID，仅对 Public 地址有效。
        :param pulumi.Input[builtins.str] internet_protocol: IP 协议版本。取值为 IPv4。
        :param pulumi.Input[builtins.str] ip_address: IP 地址。
        :param pulumi.Input[builtins.str] network_type: 网络地址类型，取值为：Private：私网地址。Public：公网地址。
        :param pulumi.Input[builtins.str] port: 端口。
        :param pulumi.Input[builtins.str] subnet_id: 子网 ID，仅对 Private 地址有效。
        """
        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 internet_protocol is not None:
            pulumi.set(__self__, "internet_protocol", internet_protocol)
        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：私网解析（默认）。true：私网以及公网解析。
        """
        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]]:
        """
        EIP 的 ID，仅对 Public 地址有效。
        """
        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="internetProtocol")
    def internet_protocol(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        IP 协议版本。取值为 IPv4。
        """
        return pulumi.get(self, "internet_protocol")

    @internet_protocol.setter
    def internet_protocol(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "internet_protocol", 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：私网地址。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，仅对 Private 地址有效。
        """
        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 InstanceAutoStorageScalingConfigArgsDict(TypedDict):
        enable_storage_auto_scale: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启实例的自动扩容功能。取值：true：是。false：否。
        """
        storage_threshold: NotRequired[pulumi.Input[builtins.int]]
        """
        触发自动扩容的可用存储空间占比。取值范围为 10~50，默认值为 10，单位为 %。
        """
        storage_upper_bound: NotRequired[pulumi.Input[builtins.int]]
        """
        可自动扩容的存储空间上限。该字段的取值下限为实例存储空间+20GB；取值上限为实例主节点规格对应的存储空间取值范围的上限，单位为 GB。关于不同规格可选择存储空间取值范围的详细信息。
        """
elif False:
    InstanceAutoStorageScalingConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceAutoStorageScalingConfigArgs:
    def __init__(__self__, *,
                 enable_storage_auto_scale: Optional[pulumi.Input[builtins.bool]] = None,
                 storage_threshold: Optional[pulumi.Input[builtins.int]] = None,
                 storage_upper_bound: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.bool] enable_storage_auto_scale: 是否开启实例的自动扩容功能。取值：true：是。false：否。
        :param pulumi.Input[builtins.int] storage_threshold: 触发自动扩容的可用存储空间占比。取值范围为 10~50，默认值为 10，单位为 %。
        :param pulumi.Input[builtins.int] storage_upper_bound: 可自动扩容的存储空间上限。该字段的取值下限为实例存储空间+20GB；取值上限为实例主节点规格对应的存储空间取值范围的上限，单位为 GB。关于不同规格可选择存储空间取值范围的详细信息。
        """
        if enable_storage_auto_scale is not None:
            pulumi.set(__self__, "enable_storage_auto_scale", enable_storage_auto_scale)
        if storage_threshold is not None:
            pulumi.set(__self__, "storage_threshold", storage_threshold)
        if storage_upper_bound is not None:
            pulumi.set(__self__, "storage_upper_bound", storage_upper_bound)

    @property
    @pulumi.getter(name="enableStorageAutoScale")
    def enable_storage_auto_scale(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启实例的自动扩容功能。取值：true：是。false：否。
        """
        return pulumi.get(self, "enable_storage_auto_scale")

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

    @property
    @pulumi.getter(name="storageThreshold")
    def storage_threshold(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        触发自动扩容的可用存储空间占比。取值范围为 10~50，默认值为 10，单位为 %。
        """
        return pulumi.get(self, "storage_threshold")

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

    @property
    @pulumi.getter(name="storageUpperBound")
    def storage_upper_bound(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        可自动扩容的存储空间上限。该字段的取值下限为实例存储空间+20GB；取值上限为实例主节点规格对应的存储空间取值范围的上限，单位为 GB。关于不同规格可选择存储空间取值范围的详细信息。
        """
        return pulumi.get(self, "storage_upper_bound")

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


if not MYPY:
    class InstanceChargeDetailArgsDict(TypedDict):
        charge_type: pulumi.Input[builtins.str]
        """
        付费类型。取值为：PrePaid：包年包月。PostPaid：按量计费。
        """
        auto_renew: NotRequired[pulumi.Input[builtins.bool]]
        """
        预付费场景下是否自动续费。取值：true：自动续费。false：不自动续费。
        """
        charge_end_time: NotRequired[pulumi.Input[builtins.str]]
        """
        包年包月实例的计费结束时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        charge_start_time: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的计费开始时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        charge_status: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的计费状态。取值：Normal：正常。Overdue：欠费。Unpaid：等待支付。
        """
        number: NotRequired[pulumi.Input[builtins.int]]
        """
        实例购买数量。取值范围为 1~50。默认值为 1。
        """
        overdue_reclaim_time: NotRequired[pulumi.Input[builtins.str]]
        """
        实例欠费关停（按量付费）或到期关停（包年包月）后，预计被释放的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        overdue_time: NotRequired[pulumi.Input[builtins.str]]
        """
        实例欠费关停（按量付费）或到期关停（包年包月）的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        period: NotRequired[pulumi.Input[builtins.int]]
        """
        预付费场景下的购买时长。
        """
        period_unit: NotRequired[pulumi.Input[builtins.str]]
        """
        预付费场景下的购买周期。Month：购买周期为月。默认。Year：购买周期为年。
        """
        temp_modify_end_time: NotRequired[pulumi.Input[builtins.str]]
        """
        临时升配的还原时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        temp_modify_start_time: NotRequired[pulumi.Input[builtins.str]]
        """
        临时升配的开始时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
elif False:
    InstanceChargeDetailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceChargeDetailArgs:
    def __init__(__self__, *,
                 charge_type: pulumi.Input[builtins.str],
                 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,
                 number: Optional[pulumi.Input[builtins.int]] = 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,
                 temp_modify_end_time: Optional[pulumi.Input[builtins.str]] = None,
                 temp_modify_start_time: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] charge_type: 付费类型。取值为：PrePaid：包年包月。PostPaid：按量计费。
        :param pulumi.Input[builtins.bool] auto_renew: 预付费场景下是否自动续费。取值：true：自动续费。false：不自动续费。
        :param pulumi.Input[builtins.str] charge_end_time: 包年包月实例的计费结束时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        :param pulumi.Input[builtins.str] charge_start_time: 实例的计费开始时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        :param pulumi.Input[builtins.str] charge_status: 实例的计费状态。取值：Normal：正常。Overdue：欠费。Unpaid：等待支付。
        :param pulumi.Input[builtins.int] number: 实例购买数量。取值范围为 1~50。默认值为 1。
        :param pulumi.Input[builtins.str] overdue_reclaim_time: 实例欠费关停（按量付费）或到期关停（包年包月）后，预计被释放的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        :param pulumi.Input[builtins.str] overdue_time: 实例欠费关停（按量付费）或到期关停（包年包月）的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        :param pulumi.Input[builtins.int] period: 预付费场景下的购买时长。
        :param pulumi.Input[builtins.str] period_unit: 预付费场景下的购买周期。Month：购买周期为月。默认。Year：购买周期为年。
        :param pulumi.Input[builtins.str] temp_modify_end_time: 临时升配的还原时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        :param pulumi.Input[builtins.str] temp_modify_start_time: 临时升配的开始时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        pulumi.set(__self__, "charge_type", charge_type)
        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 number is not None:
            pulumi.set(__self__, "number", number)
        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)
        if temp_modify_end_time is not None:
            pulumi.set(__self__, "temp_modify_end_time", temp_modify_end_time)
        if temp_modify_start_time is not None:
            pulumi.set(__self__, "temp_modify_start_time", temp_modify_start_time)

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

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

    @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]]:
        """
        包年包月实例的计费结束时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        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]]:
        """
        实例的计费开始时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        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：欠费。Unpaid：等待支付。
        """
        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
    def number(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        实例购买数量。取值范围为 1~50。默认值为 1。
        """
        return pulumi.get(self, "number")

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

    @property
    @pulumi.getter(name="overdueReclaimTime")
    def overdue_reclaim_time(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例欠费关停（按量付费）或到期关停（包年包月）后，预计被释放的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        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]]:
        """
        实例欠费关停（按量付费）或到期关停（包年包月）的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        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)

    @property
    @pulumi.getter(name="tempModifyEndTime")
    def temp_modify_end_time(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        临时升配的还原时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        return pulumi.get(self, "temp_modify_end_time")

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

    @property
    @pulumi.getter(name="tempModifyStartTime")
    def temp_modify_start_time(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        临时升配的开始时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        return pulumi.get(self, "temp_modify_start_time")

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


if not MYPY:
    class InstanceDisasterRecoveryInstanceArgsDict(TypedDict):
        dts_task_id: NotRequired[pulumi.Input[builtins.str]]
        """
        主实例与灾备实例之间同步任务的 ID。
        """
        dts_task_name: NotRequired[pulumi.Input[builtins.str]]
        """
        主实例与灾备实例之间同步任务的名称。
        """
        dts_task_status: NotRequired[pulumi.Input[builtins.str]]
        """
        主实例与灾备实例之间同步任务的状态。
        """
        instance_id: NotRequired[pulumi.Input[builtins.str]]
        """
        灾备实例的 ID。
        """
        instance_name: NotRequired[pulumi.Input[builtins.str]]
        """
        灾备实例的名称。
        """
        seconds_behind_master: NotRequired[pulumi.Input[builtins.int]]
        """
        灾备实例与主实例之间的时延。
        """
elif False:
    InstanceDisasterRecoveryInstanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceDisasterRecoveryInstanceArgs:
    def __init__(__self__, *,
                 dts_task_id: Optional[pulumi.Input[builtins.str]] = None,
                 dts_task_name: Optional[pulumi.Input[builtins.str]] = None,
                 dts_task_status: Optional[pulumi.Input[builtins.str]] = None,
                 instance_id: Optional[pulumi.Input[builtins.str]] = None,
                 instance_name: Optional[pulumi.Input[builtins.str]] = None,
                 seconds_behind_master: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] dts_task_id: 主实例与灾备实例之间同步任务的 ID。
        :param pulumi.Input[builtins.str] dts_task_name: 主实例与灾备实例之间同步任务的名称。
        :param pulumi.Input[builtins.str] dts_task_status: 主实例与灾备实例之间同步任务的状态。
        :param pulumi.Input[builtins.str] instance_id: 灾备实例的 ID。
        :param pulumi.Input[builtins.str] instance_name: 灾备实例的名称。
        :param pulumi.Input[builtins.int] seconds_behind_master: 灾备实例与主实例之间的时延。
        """
        if dts_task_id is not None:
            pulumi.set(__self__, "dts_task_id", dts_task_id)
        if dts_task_name is not None:
            pulumi.set(__self__, "dts_task_name", dts_task_name)
        if dts_task_status is not None:
            pulumi.set(__self__, "dts_task_status", dts_task_status)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if instance_name is not None:
            pulumi.set(__self__, "instance_name", instance_name)
        if seconds_behind_master is not None:
            pulumi.set(__self__, "seconds_behind_master", seconds_behind_master)

    @property
    @pulumi.getter(name="dtsTaskId")
    def dts_task_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        主实例与灾备实例之间同步任务的 ID。
        """
        return pulumi.get(self, "dts_task_id")

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

    @property
    @pulumi.getter(name="dtsTaskName")
    def dts_task_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        主实例与灾备实例之间同步任务的名称。
        """
        return pulumi.get(self, "dts_task_name")

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

    @property
    @pulumi.getter(name="dtsTaskStatus")
    def dts_task_status(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        主实例与灾备实例之间同步任务的状态。
        """
        return pulumi.get(self, "dts_task_status")

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

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

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

    @property
    @pulumi.getter(name="instanceName")
    def instance_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        灾备实例的名称。
        """
        return pulumi.get(self, "instance_name")

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

    @property
    @pulumi.getter(name="secondsBehindMaster")
    def seconds_behind_master(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        灾备实例与主实例之间的时延。
        """
        return pulumi.get(self, "seconds_behind_master")

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


if not MYPY:
    class InstanceEndpointArgsDict(TypedDict):
        auto_add_new_nodes: NotRequired[pulumi.Input[builtins.str]]
        """
        当终端类型为读写终端或只读终端时，支持设置新节点是否自动加入。取值：Enable：自动加入Disable：不自动加入（默认）。
        """
        connection_info_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        连接终端标签。
        """
        connection_mode: NotRequired[pulumi.Input[builtins.str]]
        """
        连接终端类型。取值：Proxy：代理终端。Direct：直连终端。
        """
        connection_pool_type: NotRequired[pulumi.Input[builtins.str]]
        """
        代理终端的连接池类型。取值：Transaction：事务级连接池。默认值。Direct：直连模式。
        """
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        连接终端的描述信息。
        """
        enable_connection_persistent: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否启用连接保持。取值：true：是。false：否。
        """
        enable_read_only: NotRequired[pulumi.Input[builtins.str]]
        """
        是否已开启全局只读，取值：Enable：开启。Disable：未开启。
        """
        enable_read_write_splitting: NotRequired[pulumi.Input[builtins.str]]
        """
        是否已开启读写分离，取值：Enable：开启。Disable：未开启。
        """
        endpoint_id: NotRequired[pulumi.Input[builtins.str]]
        """
        实例连接终端 ID。
        """
        endpoint_name: NotRequired[pulumi.Input[builtins.str]]
        """
        实例连接终端名称。
        """
        endpoint_type: NotRequired[pulumi.Input[builtins.str]]
        """
        终端类型。取值为 Custom，自定义终端。
        """
        idle_connection_reclaim: NotRequired[pulumi.Input[builtins.bool]]
        """
        空闲连接回收功能是否开启。true：开启。false：不开启。
        """
        implicit_trans_split: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启事务分离。取值：true：是。false：否。
        """
        master_node_routing: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启主节点路由。取值：true：是。false：否。
        """
        master_protector_timeout: NotRequired[pulumi.Input[builtins.int]]
        """
        过载保护超时时间。取值范围为 60~7200 之间的整数，单位为秒。
        """
        multi_statements_mode: NotRequired[pulumi.Input[builtins.str]]
        """
        代理终端的 Multi-Statements 模式。取值：Strict：Strict 模式。默认值。Loose：Loose 模式。
        """
        overload_protection: NotRequired[pulumi.Input[builtins.bool]]
        """
        是否开启过载保护。取值：true：是。false：否。
        """
        read_only_node_distribution_type: NotRequired[pulumi.Input[builtins.str]]
        """
        读权重分配模式。当开通读写分离设置为 true 时需要传入此参数。在 CreateDBEndpoint 和 ModifyDBEndpoint 接口中做请求参数时，取值范围如下：LoadSchedule：负载调度。RoundRobinCustom：自定义权重的轮询调度。RoundRobinAuto：自动分配权重的轮询调度。在 DescribeDBInstanceDetail 接口中做返回参数时，取值范围如下：Default：按规格权重自动分配。Custom：自定义分配权重。RoundRobin：轮询调度。LoadSchedule：负载调度。RoundRobinCustom：自定义权重的轮询调度。RoundRobinAuto：自动分配权重的轮询调度。
        """
        read_only_node_max_delay_time: NotRequired[pulumi.Input[builtins.int]]
        """
        只读节点延迟阈值。取值范围为 1~3600，默认为 30，单位为秒。
        """
        read_only_node_weights: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceEndpointReadOnlyNodeWeightArgsDict']]]]
        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__, *,
                 auto_add_new_nodes: Optional[pulumi.Input[builtins.str]] = None,
                 connection_info_tags: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
                 connection_mode: Optional[pulumi.Input[builtins.str]] = None,
                 connection_pool_type: Optional[pulumi.Input[builtins.str]] = None,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 enable_connection_persistent: Optional[pulumi.Input[builtins.bool]] = None,
                 enable_read_only: Optional[pulumi.Input[builtins.str]] = None,
                 enable_read_write_splitting: Optional[pulumi.Input[builtins.str]] = 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,
                 idle_connection_reclaim: Optional[pulumi.Input[builtins.bool]] = None,
                 implicit_trans_split: Optional[pulumi.Input[builtins.bool]] = None,
                 master_node_routing: Optional[pulumi.Input[builtins.bool]] = None,
                 master_protector_timeout: Optional[pulumi.Input[builtins.int]] = None,
                 multi_statements_mode: Optional[pulumi.Input[builtins.str]] = None,
                 overload_protection: Optional[pulumi.Input[builtins.bool]] = None,
                 read_only_node_distribution_type: Optional[pulumi.Input[builtins.str]] = None,
                 read_only_node_max_delay_time: Optional[pulumi.Input[builtins.int]] = None,
                 read_only_node_weights: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceEndpointReadOnlyNodeWeightArgs']]]] = None,
                 read_write_mode: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] auto_add_new_nodes: 当终端类型为读写终端或只读终端时，支持设置新节点是否自动加入。取值：Enable：自动加入Disable：不自动加入（默认）。
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] connection_info_tags: 连接终端标签。
        :param pulumi.Input[builtins.str] connection_mode: 连接终端类型。取值：Proxy：代理终端。Direct：直连终端。
        :param pulumi.Input[builtins.str] connection_pool_type: 代理终端的连接池类型。取值：Transaction：事务级连接池。默认值。Direct：直连模式。
        :param pulumi.Input[builtins.str] description: 连接终端的描述信息。
        :param pulumi.Input[builtins.bool] enable_connection_persistent: 是否启用连接保持。取值：true：是。false：否。
        :param pulumi.Input[builtins.str] enable_read_only: 是否已开启全局只读，取值：Enable：开启。Disable：未开启。
        :param pulumi.Input[builtins.str] enable_read_write_splitting: 是否已开启读写分离，取值：Enable：开启。Disable：未开启。
        :param pulumi.Input[builtins.str] endpoint_id: 实例连接终端 ID。
        :param pulumi.Input[builtins.str] endpoint_name: 实例连接终端名称。
        :param pulumi.Input[builtins.str] endpoint_type: 终端类型。取值为 Custom，自定义终端。
        :param pulumi.Input[builtins.bool] idle_connection_reclaim: 空闲连接回收功能是否开启。true：开启。false：不开启。
        :param pulumi.Input[builtins.bool] implicit_trans_split: 是否开启事务分离。取值：true：是。false：否。
        :param pulumi.Input[builtins.bool] master_node_routing: 是否开启主节点路由。取值：true：是。false：否。
        :param pulumi.Input[builtins.int] master_protector_timeout: 过载保护超时时间。取值范围为 60~7200 之间的整数，单位为秒。
        :param pulumi.Input[builtins.str] multi_statements_mode: 代理终端的 Multi-Statements 模式。取值：Strict：Strict 模式。默认值。Loose：Loose 模式。
        :param pulumi.Input[builtins.bool] overload_protection: 是否开启过载保护。取值：true：是。false：否。
        :param pulumi.Input[builtins.str] read_only_node_distribution_type: 读权重分配模式。当开通读写分离设置为 true 时需要传入此参数。在 CreateDBEndpoint 和 ModifyDBEndpoint 接口中做请求参数时，取值范围如下：LoadSchedule：负载调度。RoundRobinCustom：自定义权重的轮询调度。RoundRobinAuto：自动分配权重的轮询调度。在 DescribeDBInstanceDetail 接口中做返回参数时，取值范围如下：Default：按规格权重自动分配。Custom：自定义分配权重。RoundRobin：轮询调度。LoadSchedule：负载调度。RoundRobinCustom：自定义权重的轮询调度。RoundRobinAuto：自动分配权重的轮询调度。
        :param pulumi.Input[builtins.int] read_only_node_max_delay_time: 只读节点延迟阈值。取值范围为 1~3600，默认为 30，单位为秒。
        :param pulumi.Input[builtins.str] read_write_mode: 读写模式：ReadWrite：读写。ReadOnly：只读。
        """
        if auto_add_new_nodes is not None:
            pulumi.set(__self__, "auto_add_new_nodes", auto_add_new_nodes)
        if connection_info_tags is not None:
            pulumi.set(__self__, "connection_info_tags", connection_info_tags)
        if connection_mode is not None:
            pulumi.set(__self__, "connection_mode", connection_mode)
        if connection_pool_type is not None:
            pulumi.set(__self__, "connection_pool_type", connection_pool_type)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if enable_connection_persistent is not None:
            pulumi.set(__self__, "enable_connection_persistent", enable_connection_persistent)
        if enable_read_only is not None:
            pulumi.set(__self__, "enable_read_only", enable_read_only)
        if enable_read_write_splitting is not None:
            pulumi.set(__self__, "enable_read_write_splitting", enable_read_write_splitting)
        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 idle_connection_reclaim is not None:
            pulumi.set(__self__, "idle_connection_reclaim", idle_connection_reclaim)
        if implicit_trans_split is not None:
            pulumi.set(__self__, "implicit_trans_split", implicit_trans_split)
        if master_node_routing is not None:
            pulumi.set(__self__, "master_node_routing", master_node_routing)
        if master_protector_timeout is not None:
            pulumi.set(__self__, "master_protector_timeout", master_protector_timeout)
        if multi_statements_mode is not None:
            pulumi.set(__self__, "multi_statements_mode", multi_statements_mode)
        if overload_protection is not None:
            pulumi.set(__self__, "overload_protection", overload_protection)
        if read_only_node_distribution_type is not None:
            pulumi.set(__self__, "read_only_node_distribution_type", read_only_node_distribution_type)
        if read_only_node_max_delay_time is not None:
            pulumi.set(__self__, "read_only_node_max_delay_time", read_only_node_max_delay_time)
        if read_only_node_weights is not None:
            pulumi.set(__self__, "read_only_node_weights", read_only_node_weights)
        if read_write_mode is not None:
            pulumi.set(__self__, "read_write_mode", read_write_mode)

    @property
    @pulumi.getter(name="autoAddNewNodes")
    def auto_add_new_nodes(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        当终端类型为读写终端或只读终端时，支持设置新节点是否自动加入。取值：Enable：自动加入Disable：不自动加入（默认）。
        """
        return pulumi.get(self, "auto_add_new_nodes")

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

    @property
    @pulumi.getter(name="connectionInfoTags")
    def connection_info_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        连接终端标签。
        """
        return pulumi.get(self, "connection_info_tags")

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

    @property
    @pulumi.getter(name="connectionMode")
    def connection_mode(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        连接终端类型。取值：Proxy：代理终端。Direct：直连终端。
        """
        return pulumi.get(self, "connection_mode")

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

    @property
    @pulumi.getter(name="connectionPoolType")
    def connection_pool_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        代理终端的连接池类型。取值：Transaction：事务级连接池。默认值。Direct：直连模式。
        """
        return pulumi.get(self, "connection_pool_type")

    @connection_pool_type.setter
    def connection_pool_type(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "connection_pool_type", 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="enableConnectionPersistent")
    def enable_connection_persistent(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否启用连接保持。取值：true：是。false：否。
        """
        return pulumi.get(self, "enable_connection_persistent")

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

    @property
    @pulumi.getter(name="enableReadOnly")
    def enable_read_only(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        是否已开启全局只读，取值：Enable：开启。Disable：未开启。
        """
        return pulumi.get(self, "enable_read_only")

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

    @property
    @pulumi.getter(name="enableReadWriteSplitting")
    def enable_read_write_splitting(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        是否已开启读写分离，取值：Enable：开启。Disable：未开启。
        """
        return pulumi.get(self, "enable_read_write_splitting")

    @enable_read_write_splitting.setter
    def enable_read_write_splitting(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "enable_read_write_splitting", 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]]:
        """
        终端类型。取值为 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="idleConnectionReclaim")
    def idle_connection_reclaim(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        空闲连接回收功能是否开启。true：开启。false：不开启。
        """
        return pulumi.get(self, "idle_connection_reclaim")

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

    @property
    @pulumi.getter(name="implicitTransSplit")
    def implicit_trans_split(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启事务分离。取值：true：是。false：否。
        """
        return pulumi.get(self, "implicit_trans_split")

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

    @property
    @pulumi.getter(name="masterNodeRouting")
    def master_node_routing(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启主节点路由。取值：true：是。false：否。
        """
        return pulumi.get(self, "master_node_routing")

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

    @property
    @pulumi.getter(name="masterProtectorTimeout")
    def master_protector_timeout(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        过载保护超时时间。取值范围为 60~7200 之间的整数，单位为秒。
        """
        return pulumi.get(self, "master_protector_timeout")

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

    @property
    @pulumi.getter(name="multiStatementsMode")
    def multi_statements_mode(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        代理终端的 Multi-Statements 模式。取值：Strict：Strict 模式。默认值。Loose：Loose 模式。
        """
        return pulumi.get(self, "multi_statements_mode")

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

    @property
    @pulumi.getter(name="overloadProtection")
    def overload_protection(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        是否开启过载保护。取值：true：是。false：否。
        """
        return pulumi.get(self, "overload_protection")

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

    @property
    @pulumi.getter(name="readOnlyNodeDistributionType")
    def read_only_node_distribution_type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        读权重分配模式。当开通读写分离设置为 true 时需要传入此参数。在 CreateDBEndpoint 和 ModifyDBEndpoint 接口中做请求参数时，取值范围如下：LoadSchedule：负载调度。RoundRobinCustom：自定义权重的轮询调度。RoundRobinAuto：自动分配权重的轮询调度。在 DescribeDBInstanceDetail 接口中做返回参数时，取值范围如下：Default：按规格权重自动分配。Custom：自定义分配权重。RoundRobin：轮询调度。LoadSchedule：负载调度。RoundRobinCustom：自定义权重的轮询调度。RoundRobinAuto：自动分配权重的轮询调度。
        """
        return pulumi.get(self, "read_only_node_distribution_type")

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

    @property
    @pulumi.getter(name="readOnlyNodeMaxDelayTime")
    def read_only_node_max_delay_time(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        只读节点延迟阈值。取值范围为 1~3600，默认为 30，单位为秒。
        """
        return pulumi.get(self, "read_only_node_max_delay_time")

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

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

    @read_only_node_weights.setter
    def read_only_node_weights(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceEndpointReadOnlyNodeWeightArgs']]]]):
        pulumi.set(self, "read_only_node_weights", 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 InstanceEndpointReadOnlyNodeWeightArgsDict(TypedDict):
        node_id: NotRequired[pulumi.Input[builtins.str]]
        """
        只读节点需要传入 NodeId，主节点无需传入。
        """
        node_type: NotRequired[pulumi.Input[builtins.str]]
        """
        节点类型。Primary：主节点。ReadOnly：只读节点。
        """
        weight: NotRequired[pulumi.Input[builtins.int]]
        """
        节点的读权重，以 100 递增，最大值为 10000。
        """
elif False:
    InstanceEndpointReadOnlyNodeWeightArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceEndpointReadOnlyNodeWeightArgs:
    def __init__(__self__, *,
                 node_id: Optional[pulumi.Input[builtins.str]] = None,
                 node_type: Optional[pulumi.Input[builtins.str]] = None,
                 weight: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] node_id: 只读节点需要传入 NodeId，主节点无需传入。
        :param pulumi.Input[builtins.str] node_type: 节点类型。Primary：主节点。ReadOnly：只读节点。
        :param pulumi.Input[builtins.int] weight: 节点的读权重，以 100 递增，最大值为 10000。
        """
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if node_type is not None:
            pulumi.set(__self__, "node_type", node_type)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        只读节点需要传入 NodeId，主节点无需传入。
        """
        return pulumi.get(self, "node_id")

    @node_id.setter
    def node_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "node_id", 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)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        节点的读权重，以 100 递增，最大值为 10000。
        """
        return pulumi.get(self, "weight")

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


if not MYPY:
    class InstanceMaintenanceWindowArgsDict(TypedDict):
        day_kind: NotRequired[pulumi.Input[builtins.str]]
        """
        可维护周期粒度，取值为 Week，周。
        """
        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_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.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_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="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):
        node_spec: pulumi.Input[builtins.str]
        """
        节点规格。
        """
        node_type: pulumi.Input[builtins.str]
        """
        节点类型。取值：Primary：主节点。Secondary：备节点。ReadOnly：只读节点。
        """
        zone_id: pulumi.Input[builtins.str]
        """
        可用区 ID。
        """
elif False:
    InstanceNodeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceNodeArgs:
    def __init__(__self__, *,
                 node_spec: pulumi.Input[builtins.str],
                 node_type: pulumi.Input[builtins.str],
                 zone_id: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] node_spec: 节点规格。
        :param pulumi.Input[builtins.str] node_type: 节点类型。取值：Primary：主节点。Secondary：备节点。ReadOnly：只读节点。
        :param pulumi.Input[builtins.str] zone_id: 可用区 ID。
        """
        pulumi.set(__self__, "node_spec", node_spec)
        pulumi.set(__self__, "node_type", node_type)
        pulumi.set(__self__, "zone_id", zone_id)

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

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

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

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

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

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


if not MYPY:
    class InstanceProxyDetailArgsDict(TypedDict):
        db_proxy_status: NotRequired[pulumi.Input[builtins.str]]
        """
        实例的数据库代理功能状态。取值：Creating：代理开启中。Running：代理运行中。Shutdown：代理已关闭。Deleting：代理关闭中
        """
        proxy_resource_info: NotRequired[pulumi.Input['InstanceProxyDetailProxyResourceInfoArgsDict']]
        """
        实例的数据库代理服务的资源信息。
        """
elif False:
    InstanceProxyDetailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceProxyDetailArgs:
    def __init__(__self__, *,
                 db_proxy_status: Optional[pulumi.Input[builtins.str]] = None,
                 proxy_resource_info: Optional[pulumi.Input['InstanceProxyDetailProxyResourceInfoArgs']] = None):
        """
        :param pulumi.Input[builtins.str] db_proxy_status: 实例的数据库代理功能状态。取值：Creating：代理开启中。Running：代理运行中。Shutdown：代理已关闭。Deleting：代理关闭中
        :param pulumi.Input['InstanceProxyDetailProxyResourceInfoArgs'] proxy_resource_info: 实例的数据库代理服务的资源信息。
        """
        if db_proxy_status is not None:
            pulumi.set(__self__, "db_proxy_status", db_proxy_status)
        if proxy_resource_info is not None:
            pulumi.set(__self__, "proxy_resource_info", proxy_resource_info)

    @property
    @pulumi.getter(name="dbProxyStatus")
    def db_proxy_status(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        实例的数据库代理功能状态。取值：Creating：代理开启中。Running：代理运行中。Shutdown：代理已关闭。Deleting：代理关闭中
        """
        return pulumi.get(self, "db_proxy_status")

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

    @property
    @pulumi.getter(name="proxyResourceInfo")
    def proxy_resource_info(self) -> Optional[pulumi.Input['InstanceProxyDetailProxyResourceInfoArgs']]:
        """
        实例的数据库代理服务的资源信息。
        """
        return pulumi.get(self, "proxy_resource_info")

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


if not MYPY:
    class InstanceProxyDetailProxyResourceInfoArgsDict(TypedDict):
        current_proxy_cpu_num: NotRequired[pulumi.Input[builtins.int]]
        """
        实例数据库代理服务当前的核数。
        """
        max_proxy_cpu_num: NotRequired[pulumi.Input[builtins.int]]
        """
        用户可为数据库代理服务配置的最多核数。
        """
        min_proxy_cpu_num: NotRequired[pulumi.Input[builtins.int]]
        """
        用户可为数据库代理服务配置的最少核数。
        """
elif False:
    InstanceProxyDetailProxyResourceInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InstanceProxyDetailProxyResourceInfoArgs:
    def __init__(__self__, *,
                 current_proxy_cpu_num: Optional[pulumi.Input[builtins.int]] = None,
                 max_proxy_cpu_num: Optional[pulumi.Input[builtins.int]] = None,
                 min_proxy_cpu_num: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.int] current_proxy_cpu_num: 实例数据库代理服务当前的核数。
        :param pulumi.Input[builtins.int] max_proxy_cpu_num: 用户可为数据库代理服务配置的最多核数。
        :param pulumi.Input[builtins.int] min_proxy_cpu_num: 用户可为数据库代理服务配置的最少核数。
        """
        if current_proxy_cpu_num is not None:
            pulumi.set(__self__, "current_proxy_cpu_num", current_proxy_cpu_num)
        if max_proxy_cpu_num is not None:
            pulumi.set(__self__, "max_proxy_cpu_num", max_proxy_cpu_num)
        if min_proxy_cpu_num is not None:
            pulumi.set(__self__, "min_proxy_cpu_num", min_proxy_cpu_num)

    @property
    @pulumi.getter(name="currentProxyCpuNum")
    def current_proxy_cpu_num(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        实例数据库代理服务当前的核数。
        """
        return pulumi.get(self, "current_proxy_cpu_num")

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

    @property
    @pulumi.getter(name="maxProxyCpuNum")
    def max_proxy_cpu_num(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        用户可为数据库代理服务配置的最多核数。
        """
        return pulumi.get(self, "max_proxy_cpu_num")

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

    @property
    @pulumi.getter(name="minProxyCpuNum")
    def min_proxy_cpu_num(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        用户可为数据库代理服务配置的最少核数。
        """
        return pulumi.get(self, "min_proxy_cpu_num")

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


if not MYPY:
    class InstanceTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签键。
        """
        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: 标签键。
        :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]]:
        """
        标签键。
        """
        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)


