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

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

__all__ = [
    'AclAclEntry',
    'AclListener',
    'AclTag',
    'CertificateTag',
    'ListenerHealthCheck',
    'ListenerTag',
    'NlbListenerHealth',
    'NlbListenerTag',
    'NlbServerGroupHealthCheck',
    'NlbServerGroupServer',
    'NlbServerGroupTag',
    'NlbTag',
    'NlbZoneMapping',
    'RuleRedirectConfig',
    'RuleTag',
    'ServerGroupListener',
    'ServerGroupServer',
    'ServerGroupTag',
    'GetAclAclEntryResult',
    'GetAclListenerResult',
    'GetAclTagResult',
    'GetCertificateTagResult',
    'GetListenerHealthCheckResult',
    'GetListenerTagResult',
    'GetNlbListenerHealthResult',
    'GetNlbListenerTagResult',
    'GetNlbServerGroupHealthCheckResult',
    'GetNlbServerGroupServerResult',
    'GetNlbServerGroupTagResult',
    'GetNlbTagResult',
    'GetNlbZoneMappingResult',
    'GetRuleRedirectConfigResult',
    'GetRuleTagResult',
    'GetServerGroupListenerResult',
    'GetServerGroupServerResult',
    'GetServerGroupTagResult',
]

@pulumi.output_type
class AclAclEntry(dict):
    def __init__(__self__, *,
                 description: Optional[builtins.str] = None,
                 entry: Optional[builtins.str] = None):
        """
        :param builtins.str description: IP条目的描述，默认值为空字符串。必须以字母、数字或中文开头，可包含字母、数字、中文及以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255个字符。
        :param builtins.str entry: IP条目的地址段，只支持CIDR地址。支持同时传入IPv4和IPv6条目。
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if entry is not None:
            pulumi.set(__self__, "entry", entry)

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        IP条目的描述，默认值为空字符串。必须以字母、数字或中文开头，可包含字母、数字、中文及以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255个字符。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def entry(self) -> Optional[builtins.str]:
        """
        IP条目的地址段，只支持CIDR地址。支持同时传入IPv4和IPv6条目。
        """
        return pulumi.get(self, "entry")


@pulumi.output_type
class AclListener(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aclType":
            suggest = "acl_type"
        elif key == "listenerId":
            suggest = "listener_id"
        elif key == "listenerName":
            suggest = "listener_name"

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

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

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

    def __init__(__self__, *,
                 acl_type: Optional[builtins.str] = None,
                 listener_id: Optional[builtins.str] = None,
                 listener_name: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 protocol: Optional[builtins.str] = None):
        """
        :param builtins.str acl_type: 监听器对本访问控制策略组的控制方式。white：白名单。监听器监听CLB的流量时，CLB仅转发其白名单关联访问控制策略组中IP地址的请求。black：黑名单。监听器监听CLB的流量时，对于黑名单关联访问控制策略组中IP地址的请求，CLB拒绝转发。
        :param builtins.str listener_id: 监听器的ID。
        :param builtins.str listener_name: 监听器的名称。
        :param builtins.int port: 监听器的端口。
        :param builtins.str protocol: 监听器的协议。包括 TCP、UDP、HTTP、HTTPS。
        """
        if acl_type is not None:
            pulumi.set(__self__, "acl_type", acl_type)
        if listener_id is not None:
            pulumi.set(__self__, "listener_id", listener_id)
        if listener_name is not None:
            pulumi.set(__self__, "listener_name", listener_name)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter(name="aclType")
    def acl_type(self) -> Optional[builtins.str]:
        """
        监听器对本访问控制策略组的控制方式。white：白名单。监听器监听CLB的流量时，CLB仅转发其白名单关联访问控制策略组中IP地址的请求。black：黑名单。监听器监听CLB的流量时，对于黑名单关联访问控制策略组中IP地址的请求，CLB拒绝转发。
        """
        return pulumi.get(self, "acl_type")

    @property
    @pulumi.getter(name="listenerId")
    def listener_id(self) -> Optional[builtins.str]:
        """
        监听器的ID。
        """
        return pulumi.get(self, "listener_id")

    @property
    @pulumi.getter(name="listenerName")
    def listener_name(self) -> Optional[builtins.str]:
        """
        监听器的名称。
        """
        return pulumi.get(self, "listener_name")

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

    @property
    @pulumi.getter
    def protocol(self) -> Optional[builtins.str]:
        """
        监听器的协议。包括 TCP、UDP、HTTP、HTTPS。
        """
        return pulumi.get(self, "protocol")


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

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

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


@pulumi.output_type
class CertificateTag(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 ListenerHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthyThreshold":
            suggest = "healthy_threshold"
        elif key == "httpCode":
            suggest = "http_code"
        elif key == "udpExpect":
            suggest = "udp_expect"
        elif key == "udpRequest":
            suggest = "udp_request"
        elif key == "unhealthyThreshold":
            suggest = "unhealthy_threshold"

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

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

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

    def __init__(__self__, *,
                 domain: Optional[builtins.str] = None,
                 enabled: Optional[builtins.str] = None,
                 healthy_threshold: Optional[builtins.int] = None,
                 http_code: Optional[builtins.str] = None,
                 interval: Optional[builtins.int] = None,
                 method: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 timeout: Optional[builtins.int] = None,
                 udp_expect: Optional[builtins.str] = None,
                 udp_request: Optional[builtins.str] = None,
                 unhealthy_threshold: Optional[builtins.int] = None,
                 uri: Optional[builtins.str] = None):
        """
        :param builtins.str domain: 健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。需至少包含一个点号（.），且不允许以点号（.）开头或结尾。单个字符串由母、数字、中划线（-）、点号（.）字符组成，中划线（-）不得出现在字符串的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示CLB使用各后端服务器的私网IP地址进行健康检查。
        :param builtins.str enabled: 监听器是否开启健康检查功能。on（默认值）：开启。off：不开启。
        :param builtins.int healthy_threshold: 健康阈值，即连续健康检查成功的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        :param builtins.str http_code: 健康检查正常的HTTP状态码。当参数Protocol取HTTP或HTTPS，且HealthCheck.Enabled取on时，参数生效。取值如下：http*2xx （默认值）、http*3xx、http*4xx、http*5xx。多个状态码间用半角逗号“,”分隔。
        :param builtins.int interval: 执行健康检查的时间间隔，取值范围为1 ～ 300 ，默认值为2，单位为秒。
        :param builtins.str method: 监听器健康检查的方法。GET：服务器需支持GET方法。HEAD：服务器仅返回HEAD头部信息，可以降低后端开销，但要求服务器支持HEAD方法。
        :param builtins.int port: 健康检查的端口，取值范围为1-65535。
        :param builtins.int timeout: 健康检查的响应超时时间，表示如果后端服务器在指定的时间内没有正确响应，则判定为健康检查“异常”。取值范围为1 ～ 60，默认值为2，单位为秒。
        :param builtins.str udp_expect: 健康检查的预期响应字符串。只允许包含字母和数字，最大长度限制为64个字符。当参数Protocol配置UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        :param builtins.str udp_request: 执行健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字。当参数Protocol配置为UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        :param builtins.int unhealthy_threshold: 不健康阈值，即连续健康检查失败的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        :param builtins.str uri: 健康检查的路径，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。必须以字符‘/’开头。仅包含字母、数字、中划线（-）、下划线（_）、斜线/）、点号（.）、百分号（%）、英文问号（?）、#、&、等号（＝）字符。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为“/”。
        """
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if healthy_threshold is not None:
            pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        if http_code is not None:
            pulumi.set(__self__, "http_code", http_code)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if udp_expect is not None:
            pulumi.set(__self__, "udp_expect", udp_expect)
        if udp_request is not None:
            pulumi.set(__self__, "udp_request", udp_request)
        if unhealthy_threshold is not None:
            pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def domain(self) -> Optional[builtins.str]:
        """
        健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。需至少包含一个点号（.），且不允许以点号（.）开头或结尾。单个字符串由母、数字、中划线（-）、点号（.）字符组成，中划线（-）不得出现在字符串的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示CLB使用各后端服务器的私网IP地址进行健康检查。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.str]:
        """
        监听器是否开启健康检查功能。on（默认值）：开启。off：不开启。
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> Optional[builtins.int]:
        """
        健康阈值，即连续健康检查成功的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        """
        return pulumi.get(self, "healthy_threshold")

    @property
    @pulumi.getter(name="httpCode")
    def http_code(self) -> Optional[builtins.str]:
        """
        健康检查正常的HTTP状态码。当参数Protocol取HTTP或HTTPS，且HealthCheck.Enabled取on时，参数生效。取值如下：http*2xx （默认值）、http*3xx、http*4xx、http*5xx。多个状态码间用半角逗号“,”分隔。
        """
        return pulumi.get(self, "http_code")

    @property
    @pulumi.getter
    def interval(self) -> Optional[builtins.int]:
        """
        执行健康检查的时间间隔，取值范围为1 ～ 300 ，默认值为2，单位为秒。
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def method(self) -> Optional[builtins.str]:
        """
        监听器健康检查的方法。GET：服务器需支持GET方法。HEAD：服务器仅返回HEAD头部信息，可以降低后端开销，但要求服务器支持HEAD方法。
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        健康检查的端口，取值范围为1-65535。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        健康检查的响应超时时间，表示如果后端服务器在指定的时间内没有正确响应，则判定为健康检查“异常”。取值范围为1 ～ 60，默认值为2，单位为秒。
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="udpExpect")
    def udp_expect(self) -> Optional[builtins.str]:
        """
        健康检查的预期响应字符串。只允许包含字母和数字，最大长度限制为64个字符。当参数Protocol配置UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        """
        return pulumi.get(self, "udp_expect")

    @property
    @pulumi.getter(name="udpRequest")
    def udp_request(self) -> Optional[builtins.str]:
        """
        执行健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字。当参数Protocol配置为UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        """
        return pulumi.get(self, "udp_request")

    @property
    @pulumi.getter(name="unhealthyThreshold")
    def unhealthy_threshold(self) -> Optional[builtins.int]:
        """
        不健康阈值，即连续健康检查失败的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        """
        return pulumi.get(self, "unhealthy_threshold")

    @property
    @pulumi.getter
    def uri(self) -> Optional[builtins.str]:
        """
        健康检查的路径，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。必须以字符‘/’开头。仅包含字母、数字、中划线（-）、下划线（_）、斜线/）、点号（.）、百分号（%）、英文问号（?）、#、&、等号（＝）字符。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为“/”。
        """
        return pulumi.get(self, "uri")


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

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

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


@pulumi.output_type
class NlbListenerHealth(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceId":
            suggest = "instance_id"
        elif key == "serverId":
            suggest = "server_id"
        elif key == "serverType":
            suggest = "server_type"
        elif key == "updatedTime":
            suggest = "updated_time"
        elif key == "zoneId":
            suggest = "zone_id"

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

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

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

    def __init__(__self__, *,
                 instance_id: Optional[builtins.str] = None,
                 ip: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 server_id: Optional[builtins.str] = None,
                 server_type: Optional[builtins.str] = None,
                 status: Optional[builtins.str] = None,
                 updated_time: Optional[builtins.str] = None,
                 zone_id: Optional[builtins.str] = None):
        """
        :param builtins.str instance_id: 后端服务器的实例 ID或IP地址。
        :param builtins.str ip: 后端服务器的IP地址。
        :param builtins.int port: 后端服务器提供服务的端口。
        :param builtins.str server_id: 后端服务器ID。
        :param builtins.str server_type: 后端服务器的类型。ecs：云服务器实例（即主网卡）；eni：辅助网卡；ip：IP地址
        :param builtins.str status: 后端服务器的健康状态。Up：正常；Down：异常；Unused：未被使用（NLB实例已关闭跨可用区转发，且没有来自该后端服务器可用区的访问流量）。
        :param builtins.str updated_time: 健康状态最后更新时间。
        :param builtins.str zone_id: 后端服务器接收访问流量的可用区ID。
        """
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if server_id is not None:
            pulumi.set(__self__, "server_id", server_id)
        if server_type is not None:
            pulumi.set(__self__, "server_type", server_type)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if updated_time is not None:
            pulumi.set(__self__, "updated_time", updated_time)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[builtins.str]:
        """
        后端服务器的实例 ID或IP地址。
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter
    def ip(self) -> Optional[builtins.str]:
        """
        后端服务器的IP地址。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        后端服务器提供服务的端口。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="serverId")
    def server_id(self) -> Optional[builtins.str]:
        """
        后端服务器ID。
        """
        return pulumi.get(self, "server_id")

    @property
    @pulumi.getter(name="serverType")
    def server_type(self) -> Optional[builtins.str]:
        """
        后端服务器的类型。ecs：云服务器实例（即主网卡）；eni：辅助网卡；ip：IP地址
        """
        return pulumi.get(self, "server_type")

    @property
    @pulumi.getter
    def status(self) -> Optional[builtins.str]:
        """
        后端服务器的健康状态。Up：正常；Down：异常；Unused：未被使用（NLB实例已关闭跨可用区转发，且没有来自该后端服务器可用区的访问流量）。
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="updatedTime")
    def updated_time(self) -> Optional[builtins.str]:
        """
        健康状态最后更新时间。
        """
        return pulumi.get(self, "updated_time")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[builtins.str]:
        """
        后端服务器接收访问流量的可用区ID。
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class NlbListenerTag(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 NlbServerGroupHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthyThreshold":
            suggest = "healthy_threshold"
        elif key == "httpCode":
            suggest = "http_code"
        elif key == "udpExpect":
            suggest = "udp_expect"
        elif key == "udpRequest":
            suggest = "udp_request"
        elif key == "unhealthyThreshold":
            suggest = "unhealthy_threshold"

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

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

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

    def __init__(__self__, *,
                 domain: Optional[builtins.str] = None,
                 enabled: Optional[builtins.bool] = None,
                 healthy_threshold: Optional[builtins.int] = None,
                 http_code: Optional[builtins.str] = None,
                 interval: Optional[builtins.int] = None,
                 method: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 timeout: Optional[builtins.int] = None,
                 type: Optional[builtins.str] = None,
                 udp_expect: Optional[builtins.str] = None,
                 udp_request: Optional[builtins.str] = None,
                 unhealthy_threshold: Optional[builtins.int] = None,
                 uri: Optional[builtins.str] = None):
        """
        :param builtins.str domain: 健康检查的域名。
        :param builtins.bool enabled: 是否开启健康检查。
        :param builtins.int healthy_threshold: 健康检查的健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“正常”的后端服务器将被判定为健康检查“正常”。
        :param builtins.str http_code: 健康检查正常的HTTP状态码。
        :param builtins.int interval: 健康检查的时间间隔，取值范围为1 ～ 300秒，默认值为10秒。
        :param builtins.str method: 健康检查的请求方法。
        :param builtins.int port: 健康检查的端口，取值范围 1～65535。服务器组未开启全端口转发时，该参数默认为0，表示使用后端服务器的端口进行健康检查。服务器组开启全端口转发时，必须指定该参数。
        :param builtins.int timeout: 健康检查的响应超时时间，取值范围为1 ～ 60秒，默认值为3秒。如果后端服务器在指定时间内没有正确响应，则判定为健康检查“异常”。
        :param builtins.str type: 健康检查的协议类型。取值如下：取值如下：TCP（默认值）、HTTP、UDP
        :param builtins.str udp_expect: UDP健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字符。
        :param builtins.str udp_request: UDP健康检查的预期响应字符串。
        :param builtins.int unhealthy_threshold: 健康检查的不健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“异常”的后端服务器将被判定为健康检查异常。
        :param builtins.str uri: 健康检查的路径。
        """
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if healthy_threshold is not None:
            pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        if http_code is not None:
            pulumi.set(__self__, "http_code", http_code)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if udp_expect is not None:
            pulumi.set(__self__, "udp_expect", udp_expect)
        if udp_request is not None:
            pulumi.set(__self__, "udp_request", udp_request)
        if unhealthy_threshold is not None:
            pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def domain(self) -> Optional[builtins.str]:
        """
        健康检查的域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[builtins.bool]:
        """
        是否开启健康检查。
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> Optional[builtins.int]:
        """
        健康检查的健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“正常”的后端服务器将被判定为健康检查“正常”。
        """
        return pulumi.get(self, "healthy_threshold")

    @property
    @pulumi.getter(name="httpCode")
    def http_code(self) -> Optional[builtins.str]:
        """
        健康检查正常的HTTP状态码。
        """
        return pulumi.get(self, "http_code")

    @property
    @pulumi.getter
    def interval(self) -> Optional[builtins.int]:
        """
        健康检查的时间间隔，取值范围为1 ～ 300秒，默认值为10秒。
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def method(self) -> Optional[builtins.str]:
        """
        健康检查的请求方法。
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        健康检查的端口，取值范围 1～65535。服务器组未开启全端口转发时，该参数默认为0，表示使用后端服务器的端口进行健康检查。服务器组开启全端口转发时，必须指定该参数。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        健康检查的响应超时时间，取值范围为1 ～ 60秒，默认值为3秒。如果后端服务器在指定时间内没有正确响应，则判定为健康检查“异常”。
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        健康检查的协议类型。取值如下：取值如下：TCP（默认值）、HTTP、UDP
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="udpExpect")
    def udp_expect(self) -> Optional[builtins.str]:
        """
        UDP健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字符。
        """
        return pulumi.get(self, "udp_expect")

    @property
    @pulumi.getter(name="udpRequest")
    def udp_request(self) -> Optional[builtins.str]:
        """
        UDP健康检查的预期响应字符串。
        """
        return pulumi.get(self, "udp_request")

    @property
    @pulumi.getter(name="unhealthyThreshold")
    def unhealthy_threshold(self) -> Optional[builtins.int]:
        """
        健康检查的不健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“异常”的后端服务器将被判定为健康检查异常。
        """
        return pulumi.get(self, "unhealthy_threshold")

    @property
    @pulumi.getter
    def uri(self) -> Optional[builtins.str]:
        """
        健康检查的路径。
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class NlbServerGroupServer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceId":
            suggest = "instance_id"
        elif key == "serverId":
            suggest = "server_id"
        elif key == "zoneId":
            suggest = "zone_id"

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

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

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

    def __init__(__self__, *,
                 description: Optional[builtins.str] = None,
                 instance_id: Optional[builtins.str] = None,
                 ip: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 server_id: Optional[builtins.str] = None,
                 type: Optional[builtins.str] = None,
                 weight: Optional[builtins.int] = None,
                 zone_id: Optional[builtins.str] = None):
        """
        :param builtins.str description: 后端服务器的描述，默认值为空字符串。
        :param builtins.str instance_id: 服务器实例的ID或IP地址。服务器类型为“ecs”时，传入云服务器实例的ID。您可以调用DescribeInstances接口云服务器实例ID。服务器类型为“eni”时，传入已绑定云服务器实例的网卡ID。您可以调用DescribeNetworkInterfaces接口获取网卡ID。服务器类型为“ip”时，传入后端服务器的IP地址。
        :param builtins.str ip: 后端服务器的私网IP地址。您可以调用DescribeInstances接口获取“ecs”类型后端服务器的私网IP地址。您可以调用DescribeNetworkInterfaces接口获取“eni”类型后端服务器的私网IP地址。
        :param builtins.int port: 后端服务器接收请求的端口号，取值范围为 1～65535。参数AnyPortEnabled为“false”，即服务器组未开启全端口转发时，该参数为必填。参数AnyPortEnabled为“true”，即服务器组开启全端口转发时，该参数默认为0。
        :param builtins.str server_id: 后端服务器 ID。
        :param builtins.str type: 后端服务器的类型。取值如下：ecs：云服务器实例（即主网卡）。eni：辅助网卡。ip：IP地址。
        :param builtins.int weight: 后端服务器的权重，取值范围为0 ～ 100。权重为0，表示不会将请求转发给该服务器。该参数不传入，则默认为0。
        :param builtins.str zone_id: 指定后端服务器关联的NLB实例可用区。当参数Servers.N.Type为ip时，此参数必填。NLB实例开启跨可用区转发功能时，该后端服务器可以接收来自NLB实例所有可用区的流量。NLB实例关闭跨可用区转发功能时，则该后端服务器仅接收来自指定可用区的流量。
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if server_id is not None:
            pulumi.set(__self__, "server_id", server_id)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        后端服务器的描述，默认值为空字符串。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[builtins.str]:
        """
        服务器实例的ID或IP地址。服务器类型为“ecs”时，传入云服务器实例的ID。您可以调用DescribeInstances接口云服务器实例ID。服务器类型为“eni”时，传入已绑定云服务器实例的网卡ID。您可以调用DescribeNetworkInterfaces接口获取网卡ID。服务器类型为“ip”时，传入后端服务器的IP地址。
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter
    def ip(self) -> Optional[builtins.str]:
        """
        后端服务器的私网IP地址。您可以调用DescribeInstances接口获取“ecs”类型后端服务器的私网IP地址。您可以调用DescribeNetworkInterfaces接口获取“eni”类型后端服务器的私网IP地址。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        后端服务器接收请求的端口号，取值范围为 1～65535。参数AnyPortEnabled为“false”，即服务器组未开启全端口转发时，该参数为必填。参数AnyPortEnabled为“true”，即服务器组开启全端口转发时，该参数默认为0。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="serverId")
    def server_id(self) -> Optional[builtins.str]:
        """
        后端服务器 ID。
        """
        return pulumi.get(self, "server_id")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        后端服务器的类型。取值如下：ecs：云服务器实例（即主网卡）。eni：辅助网卡。ip：IP地址。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> Optional[builtins.int]:
        """
        后端服务器的权重，取值范围为0 ～ 100。权重为0，表示不会将请求转发给该服务器。该参数不传入，则默认为0。
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[builtins.str]:
        """
        指定后端服务器关联的NLB实例可用区。当参数Servers.N.Type为ip时，此参数必填。NLB实例开启跨可用区转发功能时，该后端服务器可以接收来自NLB实例所有可用区的流量。NLB实例关闭跨可用区转发功能时，则该后端服务器仅接收来自指定可用区的流量。
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class NlbServerGroupTag(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 NlbTag(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 NlbZoneMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "eniId":
            suggest = "eni_id"
        elif key == "ipv4Address":
            suggest = "ipv4_address"
        elif key == "ipv4EipAddress":
            suggest = "ipv4_eip_address"
        elif key == "ipv4EipId":
            suggest = "ipv4_eip_id"
        elif key == "ipv4HcStatus":
            suggest = "ipv4_hc_status"
        elif key == "ipv4LocalAddresses":
            suggest = "ipv4_local_addresses"
        elif key == "ipv6Address":
            suggest = "ipv6_address"
        elif key == "ipv6EipId":
            suggest = "ipv6_eip_id"
        elif key == "ipv6HcStatus":
            suggest = "ipv6_hc_status"
        elif key == "ipv6LocalAddresses":
            suggest = "ipv6_local_addresses"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "zoneId":
            suggest = "zone_id"

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

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

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

    def __init__(__self__, *,
                 eni_id: Optional[builtins.str] = None,
                 ipv4_address: Optional[builtins.str] = None,
                 ipv4_eip_address: Optional[builtins.str] = None,
                 ipv4_eip_id: Optional[builtins.str] = None,
                 ipv4_hc_status: Optional[builtins.str] = None,
                 ipv4_local_addresses: Optional[Sequence[builtins.str]] = None,
                 ipv6_address: Optional[builtins.str] = None,
                 ipv6_eip_id: Optional[builtins.str] = None,
                 ipv6_hc_status: Optional[builtins.str] = None,
                 ipv6_local_addresses: Optional[Sequence[builtins.str]] = None,
                 subnet_id: Optional[builtins.str] = None,
                 zone_id: Optional[builtins.str] = None):
        """
        :param builtins.str eni_id: 网卡ID。
        :param builtins.str ipv4_address: NLB实例的私网IPv4 VIP地址。该参数不传入，则系统自动从子网中分配一个可用的IPv4地址。
        :param builtins.str ipv4_eip_address: NLB实例的公网IPv4 EIP地址。
        :param builtins.str ipv4_eip_id: NLB实例的公网IPv4 EIP ID。
        :param builtins.str ipv4_hc_status: NLB实例私网IPv4地址的健康状态。Healthy：健康。Unhealthy：异常。
        :param Sequence[builtins.str] ipv4_local_addresses: NLB实例的私网IPv4 LIP地址。
        :param builtins.str ipv6_address: NLB实例的私网IPv6 VIP地址。
        :param builtins.str ipv6_eip_id: NLB实例关联的IPv6公网带宽的ID。
        :param builtins.str ipv6_hc_status: NLB实例私网IPv6地址的健康状态。Healthy：健康。Unhealthy：异常。
        :param Sequence[builtins.str] ipv6_local_addresses: NLB实例的私网IPv6 LIP地址。
        :param builtins.str subnet_id: NLB实例所属的子网ID。
        :param builtins.str zone_id: NLB实例所属的可用区ID。
        """
        if eni_id is not None:
            pulumi.set(__self__, "eni_id", eni_id)
        if ipv4_address is not None:
            pulumi.set(__self__, "ipv4_address", ipv4_address)
        if ipv4_eip_address is not None:
            pulumi.set(__self__, "ipv4_eip_address", ipv4_eip_address)
        if ipv4_eip_id is not None:
            pulumi.set(__self__, "ipv4_eip_id", ipv4_eip_id)
        if ipv4_hc_status is not None:
            pulumi.set(__self__, "ipv4_hc_status", ipv4_hc_status)
        if ipv4_local_addresses is not None:
            pulumi.set(__self__, "ipv4_local_addresses", ipv4_local_addresses)
        if ipv6_address is not None:
            pulumi.set(__self__, "ipv6_address", ipv6_address)
        if ipv6_eip_id is not None:
            pulumi.set(__self__, "ipv6_eip_id", ipv6_eip_id)
        if ipv6_hc_status is not None:
            pulumi.set(__self__, "ipv6_hc_status", ipv6_hc_status)
        if ipv6_local_addresses is not None:
            pulumi.set(__self__, "ipv6_local_addresses", ipv6_local_addresses)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

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

    @property
    @pulumi.getter(name="ipv4Address")
    def ipv4_address(self) -> Optional[builtins.str]:
        """
        NLB实例的私网IPv4 VIP地址。该参数不传入，则系统自动从子网中分配一个可用的IPv4地址。
        """
        return pulumi.get(self, "ipv4_address")

    @property
    @pulumi.getter(name="ipv4EipAddress")
    def ipv4_eip_address(self) -> Optional[builtins.str]:
        """
        NLB实例的公网IPv4 EIP地址。
        """
        return pulumi.get(self, "ipv4_eip_address")

    @property
    @pulumi.getter(name="ipv4EipId")
    def ipv4_eip_id(self) -> Optional[builtins.str]:
        """
        NLB实例的公网IPv4 EIP ID。
        """
        return pulumi.get(self, "ipv4_eip_id")

    @property
    @pulumi.getter(name="ipv4HcStatus")
    def ipv4_hc_status(self) -> Optional[builtins.str]:
        """
        NLB实例私网IPv4地址的健康状态。Healthy：健康。Unhealthy：异常。
        """
        return pulumi.get(self, "ipv4_hc_status")

    @property
    @pulumi.getter(name="ipv4LocalAddresses")
    def ipv4_local_addresses(self) -> Optional[Sequence[builtins.str]]:
        """
        NLB实例的私网IPv4 LIP地址。
        """
        return pulumi.get(self, "ipv4_local_addresses")

    @property
    @pulumi.getter(name="ipv6Address")
    def ipv6_address(self) -> Optional[builtins.str]:
        """
        NLB实例的私网IPv6 VIP地址。
        """
        return pulumi.get(self, "ipv6_address")

    @property
    @pulumi.getter(name="ipv6EipId")
    def ipv6_eip_id(self) -> Optional[builtins.str]:
        """
        NLB实例关联的IPv6公网带宽的ID。
        """
        return pulumi.get(self, "ipv6_eip_id")

    @property
    @pulumi.getter(name="ipv6HcStatus")
    def ipv6_hc_status(self) -> Optional[builtins.str]:
        """
        NLB实例私网IPv6地址的健康状态。Healthy：健康。Unhealthy：异常。
        """
        return pulumi.get(self, "ipv6_hc_status")

    @property
    @pulumi.getter(name="ipv6LocalAddresses")
    def ipv6_local_addresses(self) -> Optional[Sequence[builtins.str]]:
        """
        NLB实例的私网IPv6 LIP地址。
        """
        return pulumi.get(self, "ipv6_local_addresses")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[builtins.str]:
        """
        NLB实例所属的子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[builtins.str]:
        """
        NLB实例所属的可用区ID。
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class RuleRedirectConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "statusCode":
            suggest = "status_code"

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

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

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

    def __init__(__self__, *,
                 host: Optional[builtins.str] = None,
                 path: Optional[builtins.str] = None,
                 port: Optional[builtins.str] = None,
                 protocol: Optional[builtins.str] = None,
                 status_code: Optional[builtins.str] = None):
        """
        :param builtins.str host: 转发规则重定向的域名，当前仅支持精确域名。规范如下：需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含字母、数字、‘.’、‘-‘。长度限制为1 ～ 128个字符。符合域名规范的精确域名，例如：www.test.com。
        :param builtins.str path: 转发规则重定向的路径。规范如下：必须以正斜线“/”开头，字符‘/’不能连续出现。仅允许包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’等字符。长度限制为1 ～ 128个字符。
        :param builtins.str port: 转发规则重定向的端口，取值范围为 1~65535。
        :param builtins.str protocol: 转发规则重定向的协议。取值如下：HTTP。HTTPS（默认值）。
        :param builtins.str status_code: 转发规则重定向的状态码。取值如下：301（默认）：表示请求的资源已被永久移动到新的 URL，客户端应该使用新的 URL 进行后续请求。302：表示请求的资源被临时移动到新的 URL，但未来可能会再次更改，客户端应该使用新的 URL 进行后续请求。307：与 302 类似，但在重定向时要求客户端保持请求方法不变。例如，原来是 GET 请求，则重定向后仍然是 GET 请求。308：与 301 类似，但在重定向时要求客户端保持请求方法不变。
        """
        if host is not None:
            pulumi.set(__self__, "host", host)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if status_code is not None:
            pulumi.set(__self__, "status_code", status_code)

    @property
    @pulumi.getter
    def host(self) -> Optional[builtins.str]:
        """
        转发规则重定向的域名，当前仅支持精确域名。规范如下：需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含字母、数字、‘.’、‘-‘。长度限制为1 ～ 128个字符。符合域名规范的精确域名，例如：www.test.com。
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        """
        转发规则重定向的路径。规范如下：必须以正斜线“/”开头，字符‘/’不能连续出现。仅允许包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’等字符。长度限制为1 ～ 128个字符。
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.str]:
        """
        转发规则重定向的端口，取值范围为 1~65535。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[builtins.str]:
        """
        转发规则重定向的协议。取值如下：HTTP。HTTPS（默认值）。
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="statusCode")
    def status_code(self) -> Optional[builtins.str]:
        """
        转发规则重定向的状态码。取值如下：301（默认）：表示请求的资源已被永久移动到新的 URL，客户端应该使用新的 URL 进行后续请求。302：表示请求的资源被临时移动到新的 URL，但未来可能会再次更改，客户端应该使用新的 URL 进行后续请求。307：与 302 类似，但在重定向时要求客户端保持请求方法不变。例如，原来是 GET 请求，则重定向后仍然是 GET 请求。308：与 301 类似，但在重定向时要求客户端保持请求方法不变。
        """
        return pulumi.get(self, "status_code")


@pulumi.output_type
class RuleTag(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 ServerGroupListener(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "listenerId":
            suggest = "listener_id"

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

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

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

    def __init__(__self__, *,
                 listener_id: Optional[builtins.str] = None):
        """
        :param builtins.str listener_id: 监听器的ID。
        """
        if listener_id is not None:
            pulumi.set(__self__, "listener_id", listener_id)

    @property
    @pulumi.getter(name="listenerId")
    def listener_id(self) -> Optional[builtins.str]:
        """
        监听器的ID。
        """
        return pulumi.get(self, "listener_id")


@pulumi.output_type
class ServerGroupServer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instanceId":
            suggest = "instance_id"

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

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

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

    def __init__(__self__, *,
                 description: Optional[builtins.str] = None,
                 instance_id: Optional[builtins.str] = None,
                 ip: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 type: Optional[builtins.str] = None,
                 weight: Optional[builtins.int] = None):
        """
        :param builtins.str description: 后端服务器的描述。必须以字母、数字或中文开头，可包含字母、数字、中文和以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255字符。不填则默认为空字符串。
        :param builtins.str instance_id: 后端服务器。取值情况如下：当 Type 取ecs时，传云服务器实例的ID。当Type 取eni时，传已挂载至云服务器的辅助网卡的ID。当 Type 取ip时，传IP地址作为后端服务器。
        :param builtins.str ip: 后端服务器的私网IP地址。多个后端服务器IP之间使用“&”分隔。
        :param builtins.int port: 后端服务器接收请求的端口号。取值范围为1～65535。参数AnyPortEnabled为“off”，且需要同时添加后端服务器时，该参数必须传入；参数AnyPortEnabled为“on”时，该参数默认为0。
        :param builtins.str type: 后端服务器实例类型。当参数Type取instance时，取值如下：ecs：云服务器实例。eni：网卡。当参数Type取ip时，本参数取值为ip。
        :param builtins.int weight: 后端服务器的权重，取值范围为0 ～ 100。不填则默认为0。0表示不会将请求转发给该后端服务器。
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if instance_id is not None:
            pulumi.set(__self__, "instance_id", instance_id)
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter
    def description(self) -> Optional[builtins.str]:
        """
        后端服务器的描述。必须以字母、数字或中文开头，可包含字母、数字、中文和以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255字符。不填则默认为空字符串。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[builtins.str]:
        """
        后端服务器。取值情况如下：当 Type 取ecs时，传云服务器实例的ID。当Type 取eni时，传已挂载至云服务器的辅助网卡的ID。当 Type 取ip时，传IP地址作为后端服务器。
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter
    def ip(self) -> Optional[builtins.str]:
        """
        后端服务器的私网IP地址。多个后端服务器IP之间使用“&”分隔。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        后端服务器接收请求的端口号。取值范围为1～65535。参数AnyPortEnabled为“off”，且需要同时添加后端服务器时，该参数必须传入；参数AnyPortEnabled为“on”时，该参数默认为0。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        后端服务器实例类型。当参数Type取instance时，取值如下：ecs：云服务器实例。eni：网卡。当参数Type取ip时，本参数取值为ip。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> Optional[builtins.int]:
        """
        后端服务器的权重，取值范围为0 ～ 100。不填则默认为0。0表示不会将请求转发给该后端服务器。
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class ServerGroupTag(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 GetAclAclEntryResult(dict):
    def __init__(__self__, *,
                 description: builtins.str,
                 entry: builtins.str):
        """
        :param builtins.str description: IP条目的描述，默认值为空字符串。必须以字母、数字或中文开头，可包含字母、数字、中文及以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255个字符。
        :param builtins.str entry: IP条目的地址段，只支持CIDR地址。支持同时传入IPv4和IPv6条目。
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "entry", entry)

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        IP条目的描述，默认值为空字符串。必须以字母、数字或中文开头，可包含字母、数字、中文及以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255个字符。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def entry(self) -> builtins.str:
        """
        IP条目的地址段，只支持CIDR地址。支持同时传入IPv4和IPv6条目。
        """
        return pulumi.get(self, "entry")


@pulumi.output_type
class GetAclListenerResult(dict):
    def __init__(__self__, *,
                 acl_type: builtins.str,
                 listener_id: builtins.str,
                 listener_name: builtins.str,
                 port: builtins.int,
                 protocol: builtins.str):
        """
        :param builtins.str acl_type: 监听器对本访问控制策略组的控制方式。white：白名单。监听器监听CLB的流量时，CLB仅转发其白名单关联访问控制策略组中IP地址的请求。black：黑名单。监听器监听CLB的流量时，对于黑名单关联访问控制策略组中IP地址的请求，CLB拒绝转发。
        :param builtins.str listener_id: 监听器的ID。
        :param builtins.str listener_name: 监听器的名称。
        :param builtins.int port: 监听器的端口。
        :param builtins.str protocol: 监听器的协议。包括 TCP、UDP、HTTP、HTTPS。
        """
        pulumi.set(__self__, "acl_type", acl_type)
        pulumi.set(__self__, "listener_id", listener_id)
        pulumi.set(__self__, "listener_name", listener_name)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter(name="aclType")
    def acl_type(self) -> builtins.str:
        """
        监听器对本访问控制策略组的控制方式。white：白名单。监听器监听CLB的流量时，CLB仅转发其白名单关联访问控制策略组中IP地址的请求。black：黑名单。监听器监听CLB的流量时，对于黑名单关联访问控制策略组中IP地址的请求，CLB拒绝转发。
        """
        return pulumi.get(self, "acl_type")

    @property
    @pulumi.getter(name="listenerId")
    def listener_id(self) -> builtins.str:
        """
        监听器的ID。
        """
        return pulumi.get(self, "listener_id")

    @property
    @pulumi.getter(name="listenerName")
    def listener_name(self) -> builtins.str:
        """
        监听器的名称。
        """
        return pulumi.get(self, "listener_name")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        监听器的端口。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> builtins.str:
        """
        监听器的协议。包括 TCP、UDP、HTTP、HTTPS。
        """
        return pulumi.get(self, "protocol")


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

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

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


@pulumi.output_type
class GetCertificateTagResult(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")


@pulumi.output_type
class GetListenerHealthCheckResult(dict):
    def __init__(__self__, *,
                 domain: builtins.str,
                 enabled: builtins.str,
                 healthy_threshold: builtins.int,
                 http_code: builtins.str,
                 interval: builtins.int,
                 method: builtins.str,
                 port: builtins.int,
                 timeout: builtins.int,
                 udp_expect: builtins.str,
                 udp_request: builtins.str,
                 unhealthy_threshold: builtins.int,
                 uri: builtins.str):
        """
        :param builtins.str domain: 健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。需至少包含一个点号（.），且不允许以点号（.）开头或结尾。单个字符串由母、数字、中划线（-）、点号（.）字符组成，中划线（-）不得出现在字符串的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示CLB使用各后端服务器的私网IP地址进行健康检查。
        :param builtins.str enabled: 监听器是否开启健康检查功能。on（默认值）：开启。off：不开启。
        :param builtins.int healthy_threshold: 健康阈值，即连续健康检查成功的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        :param builtins.str http_code: 健康检查正常的HTTP状态码。当参数Protocol取HTTP或HTTPS，且HealthCheck.Enabled取on时，参数生效。取值如下：http*2xx （默认值）、http*3xx、http*4xx、http*5xx。多个状态码间用半角逗号“,”分隔。
        :param builtins.int interval: 执行健康检查的时间间隔，取值范围为1 ～ 300 ，默认值为2，单位为秒。
        :param builtins.str method: 监听器健康检查的方法。GET：服务器需支持GET方法。HEAD：服务器仅返回HEAD头部信息，可以降低后端开销，但要求服务器支持HEAD方法。
        :param builtins.int port: 健康检查的端口，取值范围为1-65535。
        :param builtins.int timeout: 健康检查的响应超时时间，表示如果后端服务器在指定的时间内没有正确响应，则判定为健康检查“异常”。取值范围为1 ～ 60，默认值为2，单位为秒。
        :param builtins.str udp_expect: 健康检查的预期响应字符串。只允许包含字母和数字，最大长度限制为64个字符。当参数Protocol配置UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        :param builtins.str udp_request: 执行健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字。当参数Protocol配置为UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        :param builtins.int unhealthy_threshold: 不健康阈值，即连续健康检查失败的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        :param builtins.str uri: 健康检查的路径，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。必须以字符‘/’开头。仅包含字母、数字、中划线（-）、下划线（_）、斜线/）、点号（.）、百分号（%）、英文问号（?）、#、&、等号（＝）字符。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为“/”。
        """
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        pulumi.set(__self__, "http_code", http_code)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "timeout", timeout)
        pulumi.set(__self__, "udp_expect", udp_expect)
        pulumi.set(__self__, "udp_request", udp_request)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。需至少包含一个点号（.），且不允许以点号（.）开头或结尾。单个字符串由母、数字、中划线（-）、点号（.）字符组成，中划线（-）不得出现在字符串的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示CLB使用各后端服务器的私网IP地址进行健康检查。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def enabled(self) -> builtins.str:
        """
        监听器是否开启健康检查功能。on（默认值）：开启。off：不开启。
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> builtins.int:
        """
        健康阈值，即连续健康检查成功的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        """
        return pulumi.get(self, "healthy_threshold")

    @property
    @pulumi.getter(name="httpCode")
    def http_code(self) -> builtins.str:
        """
        健康检查正常的HTTP状态码。当参数Protocol取HTTP或HTTPS，且HealthCheck.Enabled取on时，参数生效。取值如下：http*2xx （默认值）、http*3xx、http*4xx、http*5xx。多个状态码间用半角逗号“,”分隔。
        """
        return pulumi.get(self, "http_code")

    @property
    @pulumi.getter
    def interval(self) -> builtins.int:
        """
        执行健康检查的时间间隔，取值范围为1 ～ 300 ，默认值为2，单位为秒。
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def method(self) -> builtins.str:
        """
        监听器健康检查的方法。GET：服务器需支持GET方法。HEAD：服务器仅返回HEAD头部信息，可以降低后端开销，但要求服务器支持HEAD方法。
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        健康检查的端口，取值范围为1-65535。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def timeout(self) -> builtins.int:
        """
        健康检查的响应超时时间，表示如果后端服务器在指定的时间内没有正确响应，则判定为健康检查“异常”。取值范围为1 ～ 60，默认值为2，单位为秒。
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="udpExpect")
    def udp_expect(self) -> builtins.str:
        """
        健康检查的预期响应字符串。只允许包含字母和数字，最大长度限制为64个字符。当参数Protocol配置UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        """
        return pulumi.get(self, "udp_expect")

    @property
    @pulumi.getter(name="udpRequest")
    def udp_request(self) -> builtins.str:
        """
        执行健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字。当参数Protocol配置为UDP，且参数HealthCheck.Enabled配置为on时，该参数生效。参数HealthCheck.UdpRequest和HealthCheck.UdpExpect的取值只能同时为空或同时不为空。
        """
        return pulumi.get(self, "udp_request")

    @property
    @pulumi.getter(name="unhealthyThreshold")
    def unhealthy_threshold(self) -> builtins.int:
        """
        不健康阈值，即连续健康检查失败的次数。取值范围为2 ～ 10，默认值为3，单位为次。
        """
        return pulumi.get(self, "unhealthy_threshold")

    @property
    @pulumi.getter
    def uri(self) -> builtins.str:
        """
        健康检查的路径，需配置为后端服务器上真实对外提供服务的地址。当参数Protocol取HTTP或HTTPS，HealthCheck.Enabled取on时，本参数生效。必须以字符‘/’开头。仅包含字母、数字、中划线（-）、下划线（_）、斜线/）、点号（.）、百分号（%）、英文问号（?）、#、&、等号（＝）字符。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为“/”。
        """
        return pulumi.get(self, "uri")


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

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

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


@pulumi.output_type
class GetNlbListenerHealthResult(dict):
    def __init__(__self__, *,
                 instance_id: builtins.str,
                 ip: builtins.str,
                 port: builtins.int,
                 server_id: builtins.str,
                 server_type: builtins.str,
                 status: builtins.str,
                 updated_time: builtins.str,
                 zone_id: builtins.str):
        """
        :param builtins.str instance_id: 后端服务器的实例 ID或IP地址。
        :param builtins.str ip: 后端服务器的IP地址。
        :param builtins.int port: 后端服务器提供服务的端口。
        :param builtins.str server_id: 后端服务器ID。
        :param builtins.str server_type: 后端服务器的类型。ecs：云服务器实例（即主网卡）；eni：辅助网卡；ip：IP地址
        :param builtins.str status: 后端服务器的健康状态。Up：正常；Down：异常；Unused：未被使用（NLB实例已关闭跨可用区转发，且没有来自该后端服务器可用区的访问流量）。
        :param builtins.str updated_time: 健康状态最后更新时间。
        :param builtins.str zone_id: 后端服务器接收访问流量的可用区ID。
        """
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "server_id", server_id)
        pulumi.set(__self__, "server_type", server_type)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "updated_time", updated_time)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> builtins.str:
        """
        后端服务器的实例 ID或IP地址。
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter
    def ip(self) -> builtins.str:
        """
        后端服务器的IP地址。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        后端服务器提供服务的端口。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="serverId")
    def server_id(self) -> builtins.str:
        """
        后端服务器ID。
        """
        return pulumi.get(self, "server_id")

    @property
    @pulumi.getter(name="serverType")
    def server_type(self) -> builtins.str:
        """
        后端服务器的类型。ecs：云服务器实例（即主网卡）；eni：辅助网卡；ip：IP地址
        """
        return pulumi.get(self, "server_type")

    @property
    @pulumi.getter
    def status(self) -> builtins.str:
        """
        后端服务器的健康状态。Up：正常；Down：异常；Unused：未被使用（NLB实例已关闭跨可用区转发，且没有来自该后端服务器可用区的访问流量）。
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="updatedTime")
    def updated_time(self) -> builtins.str:
        """
        健康状态最后更新时间。
        """
        return pulumi.get(self, "updated_time")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> builtins.str:
        """
        后端服务器接收访问流量的可用区ID。
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class GetNlbListenerTagResult(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")


@pulumi.output_type
class GetNlbServerGroupHealthCheckResult(dict):
    def __init__(__self__, *,
                 domain: builtins.str,
                 enabled: builtins.bool,
                 healthy_threshold: builtins.int,
                 http_code: builtins.str,
                 interval: builtins.int,
                 method: builtins.str,
                 port: builtins.int,
                 timeout: builtins.int,
                 type: builtins.str,
                 udp_expect: builtins.str,
                 udp_request: builtins.str,
                 unhealthy_threshold: builtins.int,
                 uri: builtins.str):
        """
        :param builtins.str domain: 健康检查的域名。
        :param builtins.bool enabled: 是否开启健康检查。
        :param builtins.int healthy_threshold: 健康检查的健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“正常”的后端服务器将被判定为健康检查“正常”。
        :param builtins.str http_code: 健康检查正常的HTTP状态码。
        :param builtins.int interval: 健康检查的时间间隔，取值范围为1 ～ 300秒，默认值为10秒。
        :param builtins.str method: 健康检查的请求方法。
        :param builtins.int port: 健康检查的端口，取值范围 1～65535。服务器组未开启全端口转发时，该参数默认为0，表示使用后端服务器的端口进行健康检查。服务器组开启全端口转发时，必须指定该参数。
        :param builtins.int timeout: 健康检查的响应超时时间，取值范围为1 ～ 60秒，默认值为3秒。如果后端服务器在指定时间内没有正确响应，则判定为健康检查“异常”。
        :param builtins.str type: 健康检查的协议类型。取值如下：取值如下：TCP（默认值）、HTTP、UDP
        :param builtins.str udp_expect: UDP健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字符。
        :param builtins.str udp_request: UDP健康检查的预期响应字符串。
        :param builtins.int unhealthy_threshold: 健康检查的不健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“异常”的后端服务器将被判定为健康检查异常。
        :param builtins.str uri: 健康检查的路径。
        """
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        pulumi.set(__self__, "http_code", http_code)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "timeout", timeout)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "udp_expect", udp_expect)
        pulumi.set(__self__, "udp_request", udp_request)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        健康检查的域名。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter
    def enabled(self) -> builtins.bool:
        """
        是否开启健康检查。
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> builtins.int:
        """
        健康检查的健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“正常”的后端服务器将被判定为健康检查“正常”。
        """
        return pulumi.get(self, "healthy_threshold")

    @property
    @pulumi.getter(name="httpCode")
    def http_code(self) -> builtins.str:
        """
        健康检查正常的HTTP状态码。
        """
        return pulumi.get(self, "http_code")

    @property
    @pulumi.getter
    def interval(self) -> builtins.int:
        """
        健康检查的时间间隔，取值范围为1 ～ 300秒，默认值为10秒。
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def method(self) -> builtins.str:
        """
        健康检查的请求方法。
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        健康检查的端口，取值范围 1～65535。服务器组未开启全端口转发时，该参数默认为0，表示使用后端服务器的端口进行健康检查。服务器组开启全端口转发时，必须指定该参数。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def timeout(self) -> builtins.int:
        """
        健康检查的响应超时时间，取值范围为1 ～ 60秒，默认值为3秒。如果后端服务器在指定时间内没有正确响应，则判定为健康检查“异常”。
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        健康检查的协议类型。取值如下：取值如下：TCP（默认值）、HTTP、UDP
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter(name="udpExpect")
    def udp_expect(self) -> builtins.str:
        """
        UDP健康检查的请求字符串。只允许包含字母和数字，最大长度限制为64个字符。
        """
        return pulumi.get(self, "udp_expect")

    @property
    @pulumi.getter(name="udpRequest")
    def udp_request(self) -> builtins.str:
        """
        UDP健康检查的预期响应字符串。
        """
        return pulumi.get(self, "udp_request")

    @property
    @pulumi.getter(name="unhealthyThreshold")
    def unhealthy_threshold(self) -> builtins.int:
        """
        健康检查的不健康阈值，取值范围为2 ～ 10次，默认值为3次。连续执行指定次数的健康检查，结果均为“异常”的后端服务器将被判定为健康检查异常。
        """
        return pulumi.get(self, "unhealthy_threshold")

    @property
    @pulumi.getter
    def uri(self) -> builtins.str:
        """
        健康检查的路径。
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class GetNlbServerGroupServerResult(dict):
    def __init__(__self__, *,
                 description: builtins.str,
                 instance_id: builtins.str,
                 ip: builtins.str,
                 port: builtins.int,
                 server_id: builtins.str,
                 type: builtins.str,
                 weight: builtins.int,
                 zone_id: builtins.str):
        """
        :param builtins.str description: 后端服务器的描述，默认值为空字符串。
        :param builtins.str instance_id: 服务器实例的ID或IP地址。服务器类型为“ecs”时，传入云服务器实例的ID。您可以调用DescribeInstances接口云服务器实例ID。服务器类型为“eni”时，传入已绑定云服务器实例的网卡ID。您可以调用DescribeNetworkInterfaces接口获取网卡ID。服务器类型为“ip”时，传入后端服务器的IP地址。
        :param builtins.str ip: 后端服务器的私网IP地址。您可以调用DescribeInstances接口获取“ecs”类型后端服务器的私网IP地址。您可以调用DescribeNetworkInterfaces接口获取“eni”类型后端服务器的私网IP地址。
        :param builtins.int port: 后端服务器接收请求的端口号，取值范围为 1～65535。参数AnyPortEnabled为“false”，即服务器组未开启全端口转发时，该参数为必填。参数AnyPortEnabled为“true”，即服务器组开启全端口转发时，该参数默认为0。
        :param builtins.str server_id: 后端服务器 ID。
        :param builtins.str type: 后端服务器的类型。取值如下：ecs：云服务器实例（即主网卡）。eni：辅助网卡。ip：IP地址。
        :param builtins.int weight: 后端服务器的权重，取值范围为0 ～ 100。权重为0，表示不会将请求转发给该服务器。该参数不传入，则默认为0。
        :param builtins.str zone_id: 指定后端服务器关联的NLB实例可用区。当参数Servers.N.Type为ip时，此参数必填。NLB实例开启跨可用区转发功能时，该后端服务器可以接收来自NLB实例所有可用区的流量。NLB实例关闭跨可用区转发功能时，则该后端服务器仅接收来自指定可用区的流量。
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "server_id", server_id)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        后端服务器的描述，默认值为空字符串。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> builtins.str:
        """
        服务器实例的ID或IP地址。服务器类型为“ecs”时，传入云服务器实例的ID。您可以调用DescribeInstances接口云服务器实例ID。服务器类型为“eni”时，传入已绑定云服务器实例的网卡ID。您可以调用DescribeNetworkInterfaces接口获取网卡ID。服务器类型为“ip”时，传入后端服务器的IP地址。
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter
    def ip(self) -> builtins.str:
        """
        后端服务器的私网IP地址。您可以调用DescribeInstances接口获取“ecs”类型后端服务器的私网IP地址。您可以调用DescribeNetworkInterfaces接口获取“eni”类型后端服务器的私网IP地址。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        后端服务器接收请求的端口号，取值范围为 1～65535。参数AnyPortEnabled为“false”，即服务器组未开启全端口转发时，该参数为必填。参数AnyPortEnabled为“true”，即服务器组开启全端口转发时，该参数默认为0。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="serverId")
    def server_id(self) -> builtins.str:
        """
        后端服务器 ID。
        """
        return pulumi.get(self, "server_id")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        后端服务器的类型。取值如下：ecs：云服务器实例（即主网卡）。eni：辅助网卡。ip：IP地址。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> builtins.int:
        """
        后端服务器的权重，取值范围为0 ～ 100。权重为0，表示不会将请求转发给该服务器。该参数不传入，则默认为0。
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> builtins.str:
        """
        指定后端服务器关联的NLB实例可用区。当参数Servers.N.Type为ip时，此参数必填。NLB实例开启跨可用区转发功能时，该后端服务器可以接收来自NLB实例所有可用区的流量。NLB实例关闭跨可用区转发功能时，则该后端服务器仅接收来自指定可用区的流量。
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class GetNlbServerGroupTagResult(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")


@pulumi.output_type
class GetNlbTagResult(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")


@pulumi.output_type
class GetNlbZoneMappingResult(dict):
    def __init__(__self__, *,
                 eni_id: builtins.str,
                 ipv4_address: builtins.str,
                 ipv4_eip_address: builtins.str,
                 ipv4_eip_id: builtins.str,
                 ipv4_hc_status: builtins.str,
                 ipv4_local_addresses: Sequence[builtins.str],
                 ipv6_address: builtins.str,
                 ipv6_eip_id: builtins.str,
                 ipv6_hc_status: builtins.str,
                 ipv6_local_addresses: Sequence[builtins.str],
                 subnet_id: builtins.str,
                 zone_id: builtins.str):
        """
        :param builtins.str eni_id: 网卡ID。
        :param builtins.str ipv4_address: NLB实例的私网IPv4 VIP地址。该参数不传入，则系统自动从子网中分配一个可用的IPv4地址。
        :param builtins.str ipv4_eip_address: NLB实例的公网IPv4 EIP地址。
        :param builtins.str ipv4_eip_id: NLB实例的公网IPv4 EIP ID。
        :param builtins.str ipv4_hc_status: NLB实例私网IPv4地址的健康状态。Healthy：健康。Unhealthy：异常。
        :param Sequence[builtins.str] ipv4_local_addresses: NLB实例的私网IPv4 LIP地址。
        :param builtins.str ipv6_address: NLB实例的私网IPv6 VIP地址。
        :param builtins.str ipv6_eip_id: NLB实例关联的IPv6公网带宽的ID。
        :param builtins.str ipv6_hc_status: NLB实例私网IPv6地址的健康状态。Healthy：健康。Unhealthy：异常。
        :param Sequence[builtins.str] ipv6_local_addresses: NLB实例的私网IPv6 LIP地址。
        :param builtins.str subnet_id: NLB实例所属的子网ID。
        :param builtins.str zone_id: NLB实例所属的可用区ID。
        """
        pulumi.set(__self__, "eni_id", eni_id)
        pulumi.set(__self__, "ipv4_address", ipv4_address)
        pulumi.set(__self__, "ipv4_eip_address", ipv4_eip_address)
        pulumi.set(__self__, "ipv4_eip_id", ipv4_eip_id)
        pulumi.set(__self__, "ipv4_hc_status", ipv4_hc_status)
        pulumi.set(__self__, "ipv4_local_addresses", ipv4_local_addresses)
        pulumi.set(__self__, "ipv6_address", ipv6_address)
        pulumi.set(__self__, "ipv6_eip_id", ipv6_eip_id)
        pulumi.set(__self__, "ipv6_hc_status", ipv6_hc_status)
        pulumi.set(__self__, "ipv6_local_addresses", ipv6_local_addresses)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="eniId")
    def eni_id(self) -> builtins.str:
        """
        网卡ID。
        """
        return pulumi.get(self, "eni_id")

    @property
    @pulumi.getter(name="ipv4Address")
    def ipv4_address(self) -> builtins.str:
        """
        NLB实例的私网IPv4 VIP地址。该参数不传入，则系统自动从子网中分配一个可用的IPv4地址。
        """
        return pulumi.get(self, "ipv4_address")

    @property
    @pulumi.getter(name="ipv4EipAddress")
    def ipv4_eip_address(self) -> builtins.str:
        """
        NLB实例的公网IPv4 EIP地址。
        """
        return pulumi.get(self, "ipv4_eip_address")

    @property
    @pulumi.getter(name="ipv4EipId")
    def ipv4_eip_id(self) -> builtins.str:
        """
        NLB实例的公网IPv4 EIP ID。
        """
        return pulumi.get(self, "ipv4_eip_id")

    @property
    @pulumi.getter(name="ipv4HcStatus")
    def ipv4_hc_status(self) -> builtins.str:
        """
        NLB实例私网IPv4地址的健康状态。Healthy：健康。Unhealthy：异常。
        """
        return pulumi.get(self, "ipv4_hc_status")

    @property
    @pulumi.getter(name="ipv4LocalAddresses")
    def ipv4_local_addresses(self) -> Sequence[builtins.str]:
        """
        NLB实例的私网IPv4 LIP地址。
        """
        return pulumi.get(self, "ipv4_local_addresses")

    @property
    @pulumi.getter(name="ipv6Address")
    def ipv6_address(self) -> builtins.str:
        """
        NLB实例的私网IPv6 VIP地址。
        """
        return pulumi.get(self, "ipv6_address")

    @property
    @pulumi.getter(name="ipv6EipId")
    def ipv6_eip_id(self) -> builtins.str:
        """
        NLB实例关联的IPv6公网带宽的ID。
        """
        return pulumi.get(self, "ipv6_eip_id")

    @property
    @pulumi.getter(name="ipv6HcStatus")
    def ipv6_hc_status(self) -> builtins.str:
        """
        NLB实例私网IPv6地址的健康状态。Healthy：健康。Unhealthy：异常。
        """
        return pulumi.get(self, "ipv6_hc_status")

    @property
    @pulumi.getter(name="ipv6LocalAddresses")
    def ipv6_local_addresses(self) -> Sequence[builtins.str]:
        """
        NLB实例的私网IPv6 LIP地址。
        """
        return pulumi.get(self, "ipv6_local_addresses")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        NLB实例所属的子网ID。
        """
        return pulumi.get(self, "subnet_id")

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


@pulumi.output_type
class GetRuleRedirectConfigResult(dict):
    def __init__(__self__, *,
                 host: builtins.str,
                 path: builtins.str,
                 port: builtins.str,
                 protocol: builtins.str,
                 status_code: builtins.str):
        """
        :param builtins.str host: 转发规则重定向的域名，当前仅支持精确域名。规范如下：需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含字母、数字、‘.’、‘-‘。长度限制为1 ～ 128个字符。符合域名规范的精确域名，例如：www.test.com。
        :param builtins.str path: 转发规则重定向的路径。规范如下：必须以正斜线“/”开头，字符‘/’不能连续出现。仅允许包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’等字符。长度限制为1 ～ 128个字符。
        :param builtins.str port: 转发规则重定向的端口，取值范围为 1~65535。
        :param builtins.str protocol: 转发规则重定向的协议。取值如下：HTTP。HTTPS（默认值）。
        :param builtins.str status_code: 转发规则重定向的状态码。取值如下：301（默认）：表示请求的资源已被永久移动到新的 URL，客户端应该使用新的 URL 进行后续请求。302：表示请求的资源被临时移动到新的 URL，但未来可能会再次更改，客户端应该使用新的 URL 进行后续请求。307：与 302 类似，但在重定向时要求客户端保持请求方法不变。例如，原来是 GET 请求，则重定向后仍然是 GET 请求。308：与 301 类似，但在重定向时要求客户端保持请求方法不变。
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "status_code", status_code)

    @property
    @pulumi.getter
    def host(self) -> builtins.str:
        """
        转发规则重定向的域名，当前仅支持精确域名。规范如下：需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含字母、数字、‘.’、‘-‘。长度限制为1 ～ 128个字符。符合域名规范的精确域名，例如：www.test.com。
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        转发规则重定向的路径。规范如下：必须以正斜线“/”开头，字符‘/’不能连续出现。仅允许包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’等字符。长度限制为1 ～ 128个字符。
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def port(self) -> builtins.str:
        """
        转发规则重定向的端口，取值范围为 1~65535。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> builtins.str:
        """
        转发规则重定向的协议。取值如下：HTTP。HTTPS（默认值）。
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="statusCode")
    def status_code(self) -> builtins.str:
        """
        转发规则重定向的状态码。取值如下：301（默认）：表示请求的资源已被永久移动到新的 URL，客户端应该使用新的 URL 进行后续请求。302：表示请求的资源被临时移动到新的 URL，但未来可能会再次更改，客户端应该使用新的 URL 进行后续请求。307：与 302 类似，但在重定向时要求客户端保持请求方法不变。例如，原来是 GET 请求，则重定向后仍然是 GET 请求。308：与 301 类似，但在重定向时要求客户端保持请求方法不变。
        """
        return pulumi.get(self, "status_code")


@pulumi.output_type
class GetRuleTagResult(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")


@pulumi.output_type
class GetServerGroupListenerResult(dict):
    def __init__(__self__, *,
                 listener_id: builtins.str):
        """
        :param builtins.str listener_id: 监听器的ID。
        """
        pulumi.set(__self__, "listener_id", listener_id)

    @property
    @pulumi.getter(name="listenerId")
    def listener_id(self) -> builtins.str:
        """
        监听器的ID。
        """
        return pulumi.get(self, "listener_id")


@pulumi.output_type
class GetServerGroupServerResult(dict):
    def __init__(__self__, *,
                 any_port_enabled: builtins.str,
                 description: builtins.str,
                 instance_id: builtins.str,
                 ip: builtins.str,
                 port: builtins.int,
                 server_id: builtins.str,
                 type: builtins.str,
                 weight: builtins.int):
        """
        :param builtins.str any_port_enabled: 是否开启全端口转发。on：开启。off（默认值）：关闭。
        :param builtins.str description: 后端服务器的描述。必须以字母、数字或中文开头，可包含字母、数字、中文和以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255字符。不填则默认为空字符串。
        :param builtins.str instance_id: 后端服务器。取值情况如下：当 Type 取ecs时，传云服务器实例的ID。当Type 取eni时，传已挂载至云服务器的辅助网卡的ID。当 Type 取ip时，传IP地址作为后端服务器。
        :param builtins.str ip: 后端服务器的私网IP地址。多个后端服务器IP之间使用“&”分隔。
        :param builtins.int port: 后端服务器接收请求的端口号。取值范围为1～65535。参数AnyPortEnabled为“off”，且需要同时添加后端服务器时，该参数必须传入；参数AnyPortEnabled为“on”时，该参数默认为0。
        :param builtins.str server_id: 后端服务器ID。
        :param builtins.str type: 后端服务器实例类型。当参数Type取instance时，取值如下：ecs：云服务器实例。eni：网卡。当参数Type取ip时，本参数取值为ip。
        :param builtins.int weight: 后端服务器的权重，取值范围为0 ～ 100。不填则默认为0。0表示不会将请求转发给该后端服务器。
        """
        pulumi.set(__self__, "any_port_enabled", any_port_enabled)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "ip", ip)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "server_id", server_id)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="anyPortEnabled")
    def any_port_enabled(self) -> builtins.str:
        """
        是否开启全端口转发。on：开启。off（默认值）：关闭。
        """
        return pulumi.get(self, "any_port_enabled")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        后端服务器的描述。必须以字母、数字或中文开头，可包含字母、数字、中文和以下特殊字符：英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、中划线（-）、中文逗号（，）、中文句号（。）。长度限制为0 ～ 255字符。不填则默认为空字符串。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> builtins.str:
        """
        后端服务器。取值情况如下：当 Type 取ecs时，传云服务器实例的ID。当Type 取eni时，传已挂载至云服务器的辅助网卡的ID。当 Type 取ip时，传IP地址作为后端服务器。
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter
    def ip(self) -> builtins.str:
        """
        后端服务器的私网IP地址。多个后端服务器IP之间使用“&”分隔。
        """
        return pulumi.get(self, "ip")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        后端服务器接收请求的端口号。取值范围为1～65535。参数AnyPortEnabled为“off”，且需要同时添加后端服务器时，该参数必须传入；参数AnyPortEnabled为“on”时，该参数默认为0。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="serverId")
    def server_id(self) -> builtins.str:
        """
        后端服务器ID。
        """
        return pulumi.get(self, "server_id")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        后端服务器实例类型。当参数Type取instance时，取值如下：ecs：云服务器实例。eni：网卡。当参数Type取ip时，本参数取值为ip。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> builtins.int:
        """
        后端服务器的权重，取值范围为0 ～ 100。不填则默认为0。0表示不会将请求转发给该后端服务器。
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetServerGroupTagResult(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")


