# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'DatabaseDatabasePrivilege',
    'DbAccountAccountPrivilege',
    'DbAccountTableColumnPrivilege',
    'DbAccountTableColumnPrivilegeColumnPrivilege',
    'DbAccountTableColumnPrivilegeTablePrivilege',
    'InstanceAddressObject',
    'InstanceAutoStorageScalingConfig',
    'InstanceChargeDetail',
    'InstanceDisasterRecoveryInstance',
    'InstanceEndpoint',
    'InstanceEndpointReadOnlyNodeWeight',
    'InstanceMaintenanceWindow',
    'InstanceNode',
    'InstanceProxyDetail',
    'InstanceProxyDetailProxyResourceInfo',
    'InstanceTag',
    'GetDatabaseDatabasePrivilegeResult',
    'GetDbAccountAccountPrivilegeResult',
    'GetDbAccountTableColumnPrivilegeResult',
    'GetDbAccountTableColumnPrivilegeColumnPrivilegeResult',
    'GetDbAccountTableColumnPrivilegeTablePrivilegeResult',
    'GetInstanceAddressObjectResult',
    'GetInstanceAutoStorageScalingConfigResult',
    'GetInstanceChargeDetailResult',
    'GetInstanceDisasterRecoveryInstanceResult',
    'GetInstanceEndpointResult',
    'GetInstanceEndpointReadOnlyNodeWeightResult',
    'GetInstanceMaintenanceWindowResult',
    'GetInstanceNodeResult',
    'GetInstanceProxyDetailResult',
    'GetInstanceProxyDetailProxyResourceInfoResult',
    'GetInstanceTagResult',
]

@pulumi.output_type
class DatabaseDatabasePrivilege(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountName":
            suggest = "account_name"
        elif key == "accountPrivilege":
            suggest = "account_privilege"

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

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

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

    def __init__(__self__, *,
                 account_name: Optional[builtins.str] = None,
                 account_privilege: Optional[builtins.str] = None,
                 host: Optional[builtins.str] = None):
        """
        :param builtins.str account_name: 数据库账号名称。
        :param builtins.str account_privilege: 授予的账号权限类型，取值：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。
        :param builtins.str host: 指定的数据库账号可以访问数据库的 IP 地址。默认值为 %。若指定 Host 为 %，允许该账号从任意 IP 地址访问数据库。若指定 Host 为 192.10.10.%，则表示该账号可从 192.10.10.0~192.10.10.255 之间的 IP 地址访问数据库。指定的 Host 需要添加在实例所绑定的白名单中，
        """
        if account_name is not None:
            pulumi.set(__self__, "account_name", account_name)
        if account_privilege is not None:
            pulumi.set(__self__, "account_privilege", account_privilege)
        if host is not None:
            pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> Optional[builtins.str]:
        """
        数据库账号名称。
        """
        return pulumi.get(self, "account_name")

    @property
    @pulumi.getter(name="accountPrivilege")
    def account_privilege(self) -> Optional[builtins.str]:
        """
        授予的账号权限类型，取值：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。
        """
        return pulumi.get(self, "account_privilege")

    @property
    @pulumi.getter
    def host(self) -> Optional[builtins.str]:
        """
        指定的数据库账号可以访问数据库的 IP 地址。默认值为 %。若指定 Host 为 %，允许该账号从任意 IP 地址访问数据库。若指定 Host 为 192.10.10.%，则表示该账号可从 192.10.10.0~192.10.10.255 之间的 IP 地址访问数据库。指定的 Host 需要添加在实例所绑定的白名单中，
        """
        return pulumi.get(self, "host")


@pulumi.output_type
class DbAccountAccountPrivilege(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountPrivilege":
            suggest = "account_privilege"
        elif key == "accountPrivilegeDetails":
            suggest = "account_privilege_details"
        elif key == "dbName":
            suggest = "db_name"

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

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

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

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

    @property
    @pulumi.getter(name="accountPrivilegeDetails")
    def account_privilege_details(self) -> Optional[Sequence[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")

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


@pulumi.output_type
class DbAccountTableColumnPrivilege(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "columnPrivileges":
            suggest = "column_privileges"
        elif key == "dbName":
            suggest = "db_name"
        elif key == "tablePrivileges":
            suggest = "table_privileges"

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

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

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

    def __init__(__self__, *,
                 column_privileges: Optional[Sequence['outputs.DbAccountTableColumnPrivilegeColumnPrivilege']] = None,
                 db_name: Optional[builtins.str] = None,
                 table_privileges: Optional[Sequence['outputs.DbAccountTableColumnPrivilegeTablePrivilege']] = None):
        """
        :param 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[Sequence['outputs.DbAccountTableColumnPrivilegeColumnPrivilege']]:
        return pulumi.get(self, "column_privileges")

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

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


@pulumi.output_type
class DbAccountTableColumnPrivilegeColumnPrivilege(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountPrivilegeDetails":
            suggest = "account_privilege_details"
        elif key == "columnName":
            suggest = "column_name"
        elif key == "tableName":
            suggest = "table_name"

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

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

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

    def __init__(__self__, *,
                 account_privilege_details: Optional[Sequence[builtins.str]] = None,
                 column_name: Optional[builtins.str] = None,
                 table_name: Optional[builtins.str] = None):
        """
        :param Sequence[builtins.str] account_privilege_details: 对账号进行列权限设置的权限信息。取值（可多选）：INSERT REFERENCES SELECT UPDATE说明多个权限之间使用英文逗号（,）分隔。
        :param builtins.str column_name: 对账号进行列权限设置的列的名称。
        :param 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[Sequence[builtins.str]]:
        """
        对账号进行列权限设置的权限信息。取值（可多选）：INSERT REFERENCES SELECT UPDATE说明多个权限之间使用英文逗号（,）分隔。
        """
        return pulumi.get(self, "account_privilege_details")

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

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


@pulumi.output_type
class DbAccountTableColumnPrivilegeTablePrivilege(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accountPrivilegeDetails":
            suggest = "account_privilege_details"
        elif key == "tableName":
            suggest = "table_name"

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

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

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

    def __init__(__self__, *,
                 account_privilege_details: Optional[Sequence[builtins.str]] = None,
                 table_name: Optional[builtins.str] = None):
        """
        :param Sequence[builtins.str] account_privilege_details: 账号的表权限。取值范围（可多选）：ALTER CREATE DELETE DROP INDEX INSERT SELECT SHOW VIEW TRIGGER UPDATE CREATE VIEW REFERENCES 说明多个权限之间使用英文逗号（,）分隔。
        :param 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[Sequence[builtins.str]]:
        """
        账号的表权限。取值范围（可多选）：ALTER CREATE DELETE DROP INDEX INSERT SELECT SHOW VIEW TRIGGER UPDATE CREATE VIEW REFERENCES 说明多个权限之间使用英文逗号（,）分隔。
        """
        return pulumi.get(self, "account_privilege_details")

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


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

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

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

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

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

    @property
    @pulumi.getter
    def domain(self) -> Optional[builtins.str]:
        """
        连接域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="eipId")
    def eip_id(self) -> Optional[builtins.str]:
        """
        EIP 的 ID，仅对 Public 地址有效。
        """
        return pulumi.get(self, "eip_id")

    @property
    @pulumi.getter(name="internetProtocol")
    def internet_protocol(self) -> Optional[builtins.str]:
        """
        IP 协议版本。取值为 IPv4。
        """
        return pulumi.get(self, "internet_protocol")

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

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> Optional[builtins.str]:
        """
        网络地址类型，取值为：Private：私网地址。Public：公网地址。
        """
        return pulumi.get(self, "network_type")

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

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[builtins.str]:
        """
        子网 ID，仅对 Private 地址有效。
        """
        return pulumi.get(self, "subnet_id")


@pulumi.output_type
class InstanceAutoStorageScalingConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableStorageAutoScale":
            suggest = "enable_storage_auto_scale"
        elif key == "storageThreshold":
            suggest = "storage_threshold"
        elif key == "storageUpperBound":
            suggest = "storage_upper_bound"

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

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

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

    def __init__(__self__, *,
                 enable_storage_auto_scale: Optional[builtins.bool] = None,
                 storage_threshold: Optional[builtins.int] = None,
                 storage_upper_bound: Optional[builtins.int] = None):
        """
        :param builtins.bool enable_storage_auto_scale: 是否开启实例的自动扩容功能。取值：true：是。false：否。
        :param builtins.int storage_threshold: 触发自动扩容的可用存储空间占比。取值范围为 10~50，默认值为 10，单位为 %。
        :param 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[builtins.bool]:
        """
        是否开启实例的自动扩容功能。取值：true：是。false：否。
        """
        return pulumi.get(self, "enable_storage_auto_scale")

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

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


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

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

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

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

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

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

    @property
    @pulumi.getter(name="chargeEndTime")
    def charge_end_time(self) -> Optional[builtins.str]:
        """
        包年包月实例的计费结束时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        return pulumi.get(self, "charge_end_time")

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

    @property
    @pulumi.getter(name="chargeStatus")
    def charge_status(self) -> Optional[builtins.str]:
        """
        实例的计费状态。取值：Normal：正常。Overdue：欠费。Unpaid：等待支付。
        """
        return pulumi.get(self, "charge_status")

    @property
    @pulumi.getter
    def number(self) -> Optional[builtins.int]:
        """
        实例购买数量。取值范围为 1~50。默认值为 1。
        """
        return pulumi.get(self, "number")

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

    @property
    @pulumi.getter(name="overdueTime")
    def overdue_time(self) -> Optional[builtins.str]:
        """
        实例欠费关停（按量付费）或到期关停（包年包月）的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        return pulumi.get(self, "overdue_time")

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

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

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

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


@pulumi.output_type
class InstanceDisasterRecoveryInstance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dtsTaskId":
            suggest = "dts_task_id"
        elif key == "dtsTaskName":
            suggest = "dts_task_name"
        elif key == "dtsTaskStatus":
            suggest = "dts_task_status"
        elif key == "instanceId":
            suggest = "instance_id"
        elif key == "instanceName":
            suggest = "instance_name"
        elif key == "secondsBehindMaster":
            suggest = "seconds_behind_master"

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

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

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

    def __init__(__self__, *,
                 dts_task_id: Optional[builtins.str] = None,
                 dts_task_name: Optional[builtins.str] = None,
                 dts_task_status: Optional[builtins.str] = None,
                 instance_id: Optional[builtins.str] = None,
                 instance_name: Optional[builtins.str] = None,
                 seconds_behind_master: Optional[builtins.int] = None):
        """
        :param builtins.str dts_task_id: 主实例与灾备实例之间同步任务的 ID。
        :param builtins.str dts_task_name: 主实例与灾备实例之间同步任务的名称。
        :param builtins.str dts_task_status: 主实例与灾备实例之间同步任务的状态。
        :param builtins.str instance_id: 灾备实例的 ID。
        :param builtins.str instance_name: 灾备实例的名称。
        :param 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[builtins.str]:
        """
        主实例与灾备实例之间同步任务的 ID。
        """
        return pulumi.get(self, "dts_task_id")

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

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

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

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

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


@pulumi.output_type
class InstanceEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoAddNewNodes":
            suggest = "auto_add_new_nodes"
        elif key == "connectionInfoTags":
            suggest = "connection_info_tags"
        elif key == "connectionMode":
            suggest = "connection_mode"
        elif key == "connectionPoolType":
            suggest = "connection_pool_type"
        elif key == "enableConnectionPersistent":
            suggest = "enable_connection_persistent"
        elif key == "enableReadOnly":
            suggest = "enable_read_only"
        elif key == "enableReadWriteSplitting":
            suggest = "enable_read_write_splitting"
        elif key == "endpointId":
            suggest = "endpoint_id"
        elif key == "endpointName":
            suggest = "endpoint_name"
        elif key == "endpointType":
            suggest = "endpoint_type"
        elif key == "idleConnectionReclaim":
            suggest = "idle_connection_reclaim"
        elif key == "implicitTransSplit":
            suggest = "implicit_trans_split"
        elif key == "masterNodeRouting":
            suggest = "master_node_routing"
        elif key == "masterProtectorTimeout":
            suggest = "master_protector_timeout"
        elif key == "multiStatementsMode":
            suggest = "multi_statements_mode"
        elif key == "overloadProtection":
            suggest = "overload_protection"
        elif key == "readOnlyNodeDistributionType":
            suggest = "read_only_node_distribution_type"
        elif key == "readOnlyNodeMaxDelayTime":
            suggest = "read_only_node_max_delay_time"
        elif key == "readOnlyNodeWeights":
            suggest = "read_only_node_weights"
        elif key == "readWriteMode":
            suggest = "read_write_mode"

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        连接终端的描述信息。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="enableConnectionPersistent")
    def enable_connection_persistent(self) -> Optional[builtins.bool]:
        """
        是否启用连接保持。取值：true：是。false：否。
        """
        return pulumi.get(self, "enable_connection_persistent")

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

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

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

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

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[builtins.str]:
        """
        终端类型。取值为 Custom，自定义终端。
        """
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter(name="idleConnectionReclaim")
    def idle_connection_reclaim(self) -> Optional[builtins.bool]:
        """
        空闲连接回收功能是否开启。true：开启。false：不开启。
        """
        return pulumi.get(self, "idle_connection_reclaim")

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class InstanceEndpointReadOnlyNodeWeight(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nodeId":
            suggest = "node_id"
        elif key == "nodeType":
            suggest = "node_type"

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

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

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

    def __init__(__self__, *,
                 node_id: Optional[builtins.str] = None,
                 node_type: Optional[builtins.str] = None,
                 weight: Optional[builtins.int] = None):
        """
        :param builtins.str node_id: 只读节点需要传入 NodeId，主节点无需传入。
        :param builtins.str node_type: 节点类型。Primary：主节点。ReadOnly：只读节点。
        :param 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[builtins.str]:
        """
        只读节点需要传入 NodeId，主节点无需传入。
        """
        return pulumi.get(self, "node_id")

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

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


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

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

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

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

    def __init__(__self__, *,
                 day_kind: Optional[builtins.str] = None,
                 day_of_weeks: Optional[Sequence[builtins.str]] = None,
                 maintenance_time: Optional[builtins.str] = None):
        """
        :param builtins.str day_kind: 可维护周期粒度，取值为 Week，周。
        :param Sequence[builtins.str] day_of_weeks: 指定可维护时间段在每周生效的日期。可多选。Monday：周一。Tuesday：周二。Wednesday：周三。Thursday：周四。Friday：周五。Saturday：周六。Sunday：周日。
        :param builtins.str maintenance_time: 实例的可维护时间段。格式：HH:mmZ-HH:mmZ（UTC 时间）。说明
        """
        if day_kind is not None:
            pulumi.set(__self__, "day_kind", day_kind)
        if day_of_weeks is not None:
            pulumi.set(__self__, "day_of_weeks", day_of_weeks)
        if maintenance_time is not None:
            pulumi.set(__self__, "maintenance_time", maintenance_time)

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

    @property
    @pulumi.getter(name="dayOfWeeks")
    def day_of_weeks(self) -> Optional[Sequence[builtins.str]]:
        """
        指定可维护时间段在每周生效的日期。可多选。Monday：周一。Tuesday：周二。Wednesday：周三。Thursday：周四。Friday：周五。Saturday：周六。Sunday：周日。
        """
        return pulumi.get(self, "day_of_weeks")

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


@pulumi.output_type
class InstanceNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "nodeSpec":
            suggest = "node_spec"
        elif key == "nodeType":
            suggest = "node_type"
        elif key == "zoneId":
            suggest = "zone_id"

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

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

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

    def __init__(__self__, *,
                 node_spec: builtins.str,
                 node_type: builtins.str,
                 zone_id: builtins.str):
        """
        :param builtins.str node_spec: 节点规格。
        :param builtins.str node_type: 节点类型。取值：Primary：主节点。Secondary：备节点。ReadOnly：只读节点。
        :param 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) -> builtins.str:
        """
        节点规格。
        """
        return pulumi.get(self, "node_spec")

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

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


@pulumi.output_type
class InstanceProxyDetail(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dbProxyStatus":
            suggest = "db_proxy_status"
        elif key == "proxyResourceInfo":
            suggest = "proxy_resource_info"

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

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

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

    def __init__(__self__, *,
                 db_proxy_status: Optional[builtins.str] = None,
                 proxy_resource_info: Optional['outputs.InstanceProxyDetailProxyResourceInfo'] = None):
        """
        :param builtins.str db_proxy_status: 实例的数据库代理功能状态。取值：Creating：代理开启中。Running：代理运行中。Shutdown：代理已关闭。Deleting：代理关闭中
        :param '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[builtins.str]:
        """
        实例的数据库代理功能状态。取值：Creating：代理开启中。Running：代理运行中。Shutdown：代理已关闭。Deleting：代理关闭中
        """
        return pulumi.get(self, "db_proxy_status")

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


@pulumi.output_type
class InstanceProxyDetailProxyResourceInfo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "currentProxyCpuNum":
            suggest = "current_proxy_cpu_num"
        elif key == "maxProxyCpuNum":
            suggest = "max_proxy_cpu_num"
        elif key == "minProxyCpuNum":
            suggest = "min_proxy_cpu_num"

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

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

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

    def __init__(__self__, *,
                 current_proxy_cpu_num: Optional[builtins.int] = None,
                 max_proxy_cpu_num: Optional[builtins.int] = None,
                 min_proxy_cpu_num: Optional[builtins.int] = None):
        """
        :param builtins.int current_proxy_cpu_num: 实例数据库代理服务当前的核数。
        :param builtins.int max_proxy_cpu_num: 用户可为数据库代理服务配置的最多核数。
        :param 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[builtins.int]:
        """
        实例数据库代理服务当前的核数。
        """
        return pulumi.get(self, "current_proxy_cpu_num")

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

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


@pulumi.output_type
class InstanceTag(dict):
    def __init__(__self__, *,
                 key: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str key: 标签键。
        :param builtins.str value: 标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[builtins.str]:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        标签值。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetDatabaseDatabasePrivilegeResult(dict):
    def __init__(__self__, *,
                 account_name: builtins.str,
                 account_privilege: builtins.str,
                 account_privilege_detail: builtins.str,
                 host: builtins.str):
        """
        :param builtins.str account_name: 数据库账号名称。
        :param builtins.str account_privilege: 授予的账号权限类型，取值：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。
        :param builtins.str account_privilege_detail: 数据库权限字符串。作为请求参数时，当 AccountPrivilege 取值为 Custom 时必填，取值：SELECT,INSERT,UPDATE,DELETE,CREATE,DROP,REFERENCES,INDEX,ALTER,CREATE TEMPORARY TABLES,LOCK TABLES,EXECUTE,CREATE VIEW,SHOW VIEW,CREATE ROUTINE,ALTER ROUTINE,EVENT,TRIGGER,作为返回结果时，不管 AccountPrivilege 的值是否为 Custom，都会展示 AccountPrivilege 的详细权限。
        :param builtins.str host: 指定的数据库账号可以访问数据库的 IP 地址。默认值为 %。若指定 Host 为 %，允许该账号从任意 IP 地址访问数据库。若指定 Host 为 192.10.10.%，则表示该账号可从 192.10.10.0~192.10.10.255 之间的 IP 地址访问数据库。指定的 Host 需要添加在实例所绑定的白名单中，
        """
        pulumi.set(__self__, "account_name", account_name)
        pulumi.set(__self__, "account_privilege", account_privilege)
        pulumi.set(__self__, "account_privilege_detail", account_privilege_detail)
        pulumi.set(__self__, "host", host)

    @property
    @pulumi.getter(name="accountName")
    def account_name(self) -> builtins.str:
        """
        数据库账号名称。
        """
        return pulumi.get(self, "account_name")

    @property
    @pulumi.getter(name="accountPrivilege")
    def account_privilege(self) -> builtins.str:
        """
        授予的账号权限类型，取值：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。
        """
        return pulumi.get(self, "account_privilege")

    @property
    @pulumi.getter(name="accountPrivilegeDetail")
    def account_privilege_detail(self) -> builtins.str:
        """
        数据库权限字符串。作为请求参数时，当 AccountPrivilege 取值为 Custom 时必填，取值：SELECT,INSERT,UPDATE,DELETE,CREATE,DROP,REFERENCES,INDEX,ALTER,CREATE TEMPORARY TABLES,LOCK TABLES,EXECUTE,CREATE VIEW,SHOW VIEW,CREATE ROUTINE,ALTER ROUTINE,EVENT,TRIGGER,作为返回结果时，不管 AccountPrivilege 的值是否为 Custom，都会展示 AccountPrivilege 的详细权限。
        """
        return pulumi.get(self, "account_privilege_detail")

    @property
    @pulumi.getter
    def host(self) -> builtins.str:
        """
        指定的数据库账号可以访问数据库的 IP 地址。默认值为 %。若指定 Host 为 %，允许该账号从任意 IP 地址访问数据库。若指定 Host 为 192.10.10.%，则表示该账号可从 192.10.10.0~192.10.10.255 之间的 IP 地址访问数据库。指定的 Host 需要添加在实例所绑定的白名单中，
        """
        return pulumi.get(self, "host")


@pulumi.output_type
class GetDbAccountAccountPrivilegeResult(dict):
    def __init__(__self__, *,
                 account_privilege: builtins.str,
                 account_privilege_details: Sequence[builtins.str],
                 db_name: builtins.str):
        """
        :param builtins.str account_privilege: 数据库权限的类型。取值范围：ReadWrite：读写权限。ReadOnly：只读权限。DDLOnly：仅 DDL 权限。DMLOnly：仅 DML 权限。Custom：自定义权限。Global：全局权限。None：清除账号权限。说明该参数作为请求参数时，有以下注意事项：仅支持在作为请求参数时允许取值为 Global 和 None。权限类型为单选，传多个时会报错。仅 GrantDBAccountPrivilege 接口支持为 AccountPrivilege 取值 None。当 AccountPrivilege 取值 None 时，如果 DBName 的取值为空字符串，则清除账号的所有全局权限。如果 DBName 的取值为指定数据库，则清除账号在该数据库的所有权限。
        :param Sequence[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 builtins.str db_name: 需修改账号授权的或账号已有权限的数据库名称。说明在 CreateDBAccount 和 GrantDBAccountPrivilege 接口中作为请求参数时，需确认 DBName 对应的数据库已存在。进行全局授权的修改时，应为 DBName 传空字符。
        """
        pulumi.set(__self__, "account_privilege", account_privilege)
        pulumi.set(__self__, "account_privilege_details", account_privilege_details)
        pulumi.set(__self__, "db_name", db_name)

    @property
    @pulumi.getter(name="accountPrivilege")
    def account_privilege(self) -> 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")

    @property
    @pulumi.getter(name="accountPrivilegeDetails")
    def account_privilege_details(self) -> Sequence[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")

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


@pulumi.output_type
class GetDbAccountTableColumnPrivilegeResult(dict):
    def __init__(__self__, *,
                 column_privileges: Sequence['outputs.GetDbAccountTableColumnPrivilegeColumnPrivilegeResult'],
                 db_name: builtins.str,
                 table_privileges: Sequence['outputs.GetDbAccountTableColumnPrivilegeTablePrivilegeResult']):
        """
        :param Sequence['GetDbAccountTableColumnPrivilegeColumnPrivilegeArgs'] column_privileges: 账号的列权限信息。
        :param builtins.str db_name: 对账号进行权限设置的表所属的数据库的名称。
        :param Sequence['GetDbAccountTableColumnPrivilegeTablePrivilegeArgs'] table_privileges: 账号的表权限信息。
        """
        pulumi.set(__self__, "column_privileges", column_privileges)
        pulumi.set(__self__, "db_name", db_name)
        pulumi.set(__self__, "table_privileges", table_privileges)

    @property
    @pulumi.getter(name="columnPrivileges")
    def column_privileges(self) -> Sequence['outputs.GetDbAccountTableColumnPrivilegeColumnPrivilegeResult']:
        """
        账号的列权限信息。
        """
        return pulumi.get(self, "column_privileges")

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

    @property
    @pulumi.getter(name="tablePrivileges")
    def table_privileges(self) -> Sequence['outputs.GetDbAccountTableColumnPrivilegeTablePrivilegeResult']:
        """
        账号的表权限信息。
        """
        return pulumi.get(self, "table_privileges")


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

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

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

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


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

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

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


@pulumi.output_type
class GetInstanceAddressObjectResult(dict):
    def __init__(__self__, *,
                 dns_visibility: builtins.bool,
                 domain: builtins.str,
                 eip_id: builtins.str,
                 internet_protocol: builtins.str,
                 ip_address: builtins.str,
                 network_type: builtins.str,
                 port: builtins.str,
                 subnet_id: builtins.str):
        """
        :param builtins.bool dns_visibility: false：私网解析（默认）。true：私网以及公网解析。
        :param builtins.str domain: 连接域名。
        :param builtins.str eip_id: EIP 的 ID，仅对 Public 地址有效。
        :param builtins.str internet_protocol: IP 协议版本。取值为 IPv4。
        :param builtins.str ip_address: IP 地址。
        :param builtins.str network_type: 网络地址类型，取值为：Private：私网地址。Public：公网地址。
        :param builtins.str port: 端口。
        :param builtins.str subnet_id: 子网 ID，仅对 Private 地址有效。
        """
        pulumi.set(__self__, "dns_visibility", dns_visibility)
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "eip_id", eip_id)
        pulumi.set(__self__, "internet_protocol", internet_protocol)
        pulumi.set(__self__, "ip_address", ip_address)
        pulumi.set(__self__, "network_type", network_type)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "subnet_id", subnet_id)

    @property
    @pulumi.getter(name="dnsVisibility")
    def dns_visibility(self) -> builtins.bool:
        """
        false：私网解析（默认）。true：私网以及公网解析。
        """
        return pulumi.get(self, "dns_visibility")

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        连接域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="eipId")
    def eip_id(self) -> builtins.str:
        """
        EIP 的 ID，仅对 Public 地址有效。
        """
        return pulumi.get(self, "eip_id")

    @property
    @pulumi.getter(name="internetProtocol")
    def internet_protocol(self) -> builtins.str:
        """
        IP 协议版本。取值为 IPv4。
        """
        return pulumi.get(self, "internet_protocol")

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

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> builtins.str:
        """
        网络地址类型，取值为：Private：私网地址。Public：公网地址。
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter
    def port(self) -> builtins.str:
        """
        端口。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        子网 ID，仅对 Private 地址有效。
        """
        return pulumi.get(self, "subnet_id")


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

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

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

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


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

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

    @property
    @pulumi.getter(name="chargeEndTime")
    def charge_end_time(self) -> builtins.str:
        """
        包年包月实例的计费结束时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        return pulumi.get(self, "charge_end_time")

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

    @property
    @pulumi.getter(name="chargeStatus")
    def charge_status(self) -> builtins.str:
        """
        实例的计费状态。取值：Normal：正常。Overdue：欠费。Unpaid：等待支付。
        """
        return pulumi.get(self, "charge_status")

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

    @property
    @pulumi.getter
    def number(self) -> builtins.int:
        """
        实例购买数量。取值范围为 1~50。默认值为 1。
        """
        return pulumi.get(self, "number")

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

    @property
    @pulumi.getter(name="overdueTime")
    def overdue_time(self) -> builtins.str:
        """
        实例欠费关停（按量付费）或到期关停（包年包月）的时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        return pulumi.get(self, "overdue_time")

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

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

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

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


@pulumi.output_type
class GetInstanceDisasterRecoveryInstanceResult(dict):
    def __init__(__self__, *,
                 dts_task_id: builtins.str,
                 dts_task_name: builtins.str,
                 dts_task_status: builtins.str,
                 instance_id: builtins.str,
                 instance_name: builtins.str,
                 seconds_behind_master: builtins.int):
        """
        :param builtins.str dts_task_id: 主实例与灾备实例之间同步任务的 ID。
        :param builtins.str dts_task_name: 主实例与灾备实例之间同步任务的名称。
        :param builtins.str dts_task_status: 主实例与灾备实例之间同步任务的状态。
        :param builtins.str instance_id: 灾备实例的 ID。
        :param builtins.str instance_name: 灾备实例的名称。
        :param builtins.int seconds_behind_master: 灾备实例与主实例之间的时延。
        """
        pulumi.set(__self__, "dts_task_id", dts_task_id)
        pulumi.set(__self__, "dts_task_name", dts_task_name)
        pulumi.set(__self__, "dts_task_status", dts_task_status)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "instance_name", instance_name)
        pulumi.set(__self__, "seconds_behind_master", seconds_behind_master)

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

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

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

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

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

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


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

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

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

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

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

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        连接终端的描述信息。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="enableConnectionPersistent")
    def enable_connection_persistent(self) -> builtins.bool:
        """
        是否启用连接保持。取值：true：是。false：否。
        """
        return pulumi.get(self, "enable_connection_persistent")

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

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

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

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

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> builtins.str:
        """
        终端类型。取值为 Custom，自定义终端。
        """
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter(name="idleConnectionReclaim")
    def idle_connection_reclaim(self) -> builtins.bool:
        """
        空闲连接回收功能是否开启。true：开启。false：不开启。
        """
        return pulumi.get(self, "idle_connection_reclaim")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="readOnlyNodeWeights")
    def read_only_node_weights(self) -> Sequence['outputs.GetInstanceEndpointReadOnlyNodeWeightResult']:
        """
        连接终端配置的节点列表及对应的只读权重。
        """
        return pulumi.get(self, "read_only_node_weights")

    @property
    @pulumi.getter(name="readWriteMode")
    def read_write_mode(self) -> builtins.str:
        """
        读写模式：ReadWrite：读写。ReadOnly：只读。
        """
        return pulumi.get(self, "read_write_mode")


@pulumi.output_type
class GetInstanceEndpointReadOnlyNodeWeightResult(dict):
    def __init__(__self__, *,
                 node_id: builtins.str,
                 node_type: builtins.str,
                 weight: builtins.int):
        """
        :param builtins.str node_id: 只读节点需要传入 NodeId，主节点无需传入。
        :param builtins.str node_type: 节点类型。Primary：主节点。ReadOnly：只读节点。
        :param builtins.int weight: 节点的读权重，以 100 递增，最大值为 10000。
        """
        pulumi.set(__self__, "node_id", node_id)
        pulumi.set(__self__, "node_type", node_type)
        pulumi.set(__self__, "weight", weight)

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

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

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


@pulumi.output_type
class GetInstanceMaintenanceWindowResult(dict):
    def __init__(__self__, *,
                 day_kind: builtins.str,
                 day_of_weeks: Sequence[builtins.str],
                 maintenance_time: builtins.str):
        """
        :param builtins.str day_kind: 可维护周期粒度，取值为 Week，周。
        :param Sequence[builtins.str] day_of_weeks: 指定可维护时间段在每周生效的日期。可多选。Monday：周一。Tuesday：周二。Wednesday：周三。Thursday：周四。Friday：周五。Saturday：周六。Sunday：周日。
        :param builtins.str maintenance_time: 实例的可维护时间段。格式：HH:mmZ-HH:mmZ（UTC 时间）。说明
        """
        pulumi.set(__self__, "day_kind", day_kind)
        pulumi.set(__self__, "day_of_weeks", day_of_weeks)
        pulumi.set(__self__, "maintenance_time", maintenance_time)

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

    @property
    @pulumi.getter(name="dayOfWeeks")
    def day_of_weeks(self) -> Sequence[builtins.str]:
        """
        指定可维护时间段在每周生效的日期。可多选。Monday：周一。Tuesday：周二。Wednesday：周三。Thursday：周四。Friday：周五。Saturday：周六。Sunday：周日。
        """
        return pulumi.get(self, "day_of_weeks")

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


@pulumi.output_type
class GetInstanceNodeResult(dict):
    def __init__(__self__, *,
                 create_time: builtins.str,
                 delay_replication_time: builtins.int,
                 memory: builtins.int,
                 node_id: builtins.str,
                 node_spec: builtins.str,
                 node_status: builtins.str,
                 node_type: builtins.str,
                 sync_delay: builtins.int,
                 update_time: builtins.str,
                 vcpu: builtins.int,
                 zone_id: builtins.str):
        """
        :param builtins.str create_time: 节点的创建时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        :param builtins.int delay_replication_time: 只读节点的延迟复制时间，取值为 0~604800，单位为秒。
        :param builtins.int memory: 内存大小，单位为 GB。
        :param builtins.str node_id: 节点 ID。
        :param builtins.str node_spec: 节点规格。
        :param builtins.str node_status: 节点状态，取值：Running：运行中。Creating：创建中。Deleting：删除中。Restarting：重启中。Restoring：恢复中。Updating：变更中。Upgrading：升级中。Error：错误。
        :param builtins.str node_type: 节点类型。取值：Primary：主节点。Secondary：备节点。ReadOnly：只读节点。
        :param builtins.int sync_delay: 节点与主节点之间的延迟时间。单位为毫秒（ms）。
        :param builtins.str update_time: 节点更新本地时间。
        :param builtins.int vcpu: 节点的 CPU 核数。
        :param builtins.str zone_id: 可用区 ID。
        """
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "delay_replication_time", delay_replication_time)
        pulumi.set(__self__, "memory", memory)
        pulumi.set(__self__, "node_id", node_id)
        pulumi.set(__self__, "node_spec", node_spec)
        pulumi.set(__self__, "node_status", node_status)
        pulumi.set(__self__, "node_type", node_type)
        pulumi.set(__self__, "sync_delay", sync_delay)
        pulumi.set(__self__, "update_time", update_time)
        pulumi.set(__self__, "vcpu", vcpu)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> builtins.str:
        """
        节点的创建时间（UTC 时间）。格式为 yyyy-MM-ddTHH:mm:ss.sssZ。
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter(name="delayReplicationTime")
    def delay_replication_time(self) -> builtins.int:
        """
        只读节点的延迟复制时间，取值为 0~604800，单位为秒。
        """
        return pulumi.get(self, "delay_replication_time")

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

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

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

    @property
    @pulumi.getter(name="nodeStatus")
    def node_status(self) -> builtins.str:
        """
        节点状态，取值：Running：运行中。Creating：创建中。Deleting：删除中。Restarting：重启中。Restoring：恢复中。Updating：变更中。Upgrading：升级中。Error：错误。
        """
        return pulumi.get(self, "node_status")

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

    @property
    @pulumi.getter(name="syncDelay")
    def sync_delay(self) -> builtins.int:
        """
        节点与主节点之间的延迟时间。单位为毫秒（ms）。
        """
        return pulumi.get(self, "sync_delay")

    @property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> builtins.str:
        """
        节点更新本地时间。
        """
        return pulumi.get(self, "update_time")

    @property
    @pulumi.getter
    def vcpu(self) -> builtins.int:
        """
        节点的 CPU 核数。
        """
        return pulumi.get(self, "vcpu")

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


@pulumi.output_type
class GetInstanceProxyDetailResult(dict):
    def __init__(__self__, *,
                 db_proxy_status: builtins.str,
                 proxy_resource_info: 'outputs.GetInstanceProxyDetailProxyResourceInfoResult'):
        """
        :param builtins.str db_proxy_status: 实例的数据库代理功能状态。取值：Creating：代理开启中。Running：代理运行中。Shutdown：代理已关闭。Deleting：代理关闭中
        :param 'GetInstanceProxyDetailProxyResourceInfoArgs' proxy_resource_info: 实例的数据库代理服务的资源信息。
        """
        pulumi.set(__self__, "db_proxy_status", db_proxy_status)
        pulumi.set(__self__, "proxy_resource_info", proxy_resource_info)

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

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


@pulumi.output_type
class GetInstanceProxyDetailProxyResourceInfoResult(dict):
    def __init__(__self__, *,
                 current_proxy_cpu_num: builtins.int,
                 max_proxy_cpu_num: builtins.int,
                 min_proxy_cpu_num: builtins.int):
        """
        :param builtins.int current_proxy_cpu_num: 实例数据库代理服务当前的核数。
        :param builtins.int max_proxy_cpu_num: 用户可为数据库代理服务配置的最多核数。
        :param builtins.int min_proxy_cpu_num: 用户可为数据库代理服务配置的最少核数。
        """
        pulumi.set(__self__, "current_proxy_cpu_num", current_proxy_cpu_num)
        pulumi.set(__self__, "max_proxy_cpu_num", max_proxy_cpu_num)
        pulumi.set(__self__, "min_proxy_cpu_num", min_proxy_cpu_num)

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

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

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


@pulumi.output_type
class GetInstanceTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 标签键。
        :param builtins.str value: 标签值。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        标签键。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        标签值。
        """
        return pulumi.get(self, "value")


