# 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__ = [
    'AclAclEntry',
    'AclListener',
    'AclTag',
    'CertificateTag',
    'ListenerDomainExtension',
    'ListenerServerGroup',
    'ListenerTag',
    'LoadBalancerEipBillingConfig',
    'LoadBalancerGlobalAccelerator',
    'LoadBalancerIpv6EipBillingConfig',
    'LoadBalancerTag',
    'LoadBalancerZoneMapping',
    'ServerGroupHealthCheck',
    'ServerGroupListener',
    'ServerGroupServer',
    'ServerGroupStickySessionConfig',
    'ServerGroupTag',
    'GetAclAclEntryResult',
    'GetAclListenerResult',
    'GetAclTagResult',
    'GetCertificateTagResult',
    'GetListenerDomainExtensionResult',
    'GetListenerServerGroupResult',
    'GetListenerTagResult',
    'GetLoadBalancerEipBillingConfigResult',
    'GetLoadBalancerGlobalAcceleratorResult',
    'GetLoadBalancerIpv6EipBillingConfigResult',
    'GetLoadBalancerTagResult',
    'GetLoadBalancerZoneMappingResult',
    'GetLoadBalancerZoneMappingLoadBalancerAddressResult',
    'GetLoadBalancerZoneMappingLoadBalancerAddressEipResult',
    'GetLoadBalancerZoneMappingLoadBalancerAddressEipPopLocationResult',
    'GetLoadBalancerZoneMappingLoadBalancerAddressIpv6EipResult',
    'GetServerGroupHealthCheckResult',
    'GetServerGroupListenerResult',
    'GetServerGroupServerResult',
    'GetServerGroupStickySessionConfigResult',
    '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条目的描述。不能以http://或https://开头。必须以字母或中文开头，可包含数字、英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、短横线（-）、中文逗号（，）、中文句号（。） 。长度限制为1 ～ 255个字符。不填默认为空字符串。
        :param builtins.str entry: IP条目的地址段，只支持CIDR地址。
        """
        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条目的描述。不能以http://或https://开头。必须以字母或中文开头，可包含数字、英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、短横线（-）、中文逗号（，）、中文句号（。） 。长度限制为1 ～ 255个字符。不填默认为空字符串。
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def entry(self) -> Optional[builtins.str]:
        """
        IP条目的地址段，只支持CIDR地址。
        """
        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"

        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):
        """
        :param builtins.str acl_type: 监听器对本访问控制策略组的控制方式。white：白名单方式；black：黑名单方式
        """
        if acl_type is not None:
            pulumi.set(__self__, "acl_type", acl_type)

    @property
    @pulumi.getter(name="aclType")
    def acl_type(self) -> Optional[builtins.str]:
        """
        监听器对本访问控制策略组的控制方式。white：白名单方式；black：黑名单方式
        """
        return pulumi.get(self, "acl_type")


@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个字符。大小写敏感。不能以volc:和sys:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        :param builtins.str value: 用户标签的标签值。长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        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个字符。大小写敏感。不能以volc:和sys:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        用户标签的标签值。长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        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 ListenerDomainExtension(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certCenterCertificateId":
            suggest = "cert_center_certificate_id"
        elif key == "certificateId":
            suggest = "certificate_id"
        elif key == "certificateSource":
            suggest = "certificate_source"
        elif key == "pcaLeafCertificateId":
            suggest = "pca_leaf_certificate_id"

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

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

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

    def __init__(__self__, *,
                 cert_center_certificate_id: Optional[builtins.str] = None,
                 certificate_id: Optional[builtins.str] = None,
                 certificate_source: Optional[builtins.str] = None,
                 domain: Optional[builtins.str] = None,
                 pca_leaf_certificate_id: Optional[builtins.str] = None,
                 san: Optional[builtins.str] = None):
        """
        :param builtins.str cert_center_certificate_id: 域名使用的服务器证书 ID 。当证书来源为 cert_center 时生效。
        :param builtins.str certificate_id: 域名使用的服务器证书 ID。当证书来源为 alb 时生效。
        :param builtins.str certificate_source: 域名使用的服务器证书的来源，取值：alb：表示通过 ALB 上传的证书。cert_center：表示通过火山引擎证书中心购买或上传的 SSL 证书。
        :param builtins.str domain: 域名。通常不能为空，若实例支持自动选择扩展证书，即SniAutoMatch为on，则Domain需传入空字符串。需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含小写字、字、‘.’、‘-‘、‘*’。长度限制为1 ～ 128个字符。泛域名：使用“*”代替1个或多个字符。“*”必须在域名开头或结尾。同一条域名中“*”不能出现两次。“*”前后不能有除了.以外的字符。精确域名：符合域名规范的精确域名。同一HTTPS监听器下的域名不能重复。匹配域名时，对域名的大小写不敏感。
        :param builtins.str pca_leaf_certificate_id: HTTPS监听器关联的私有叶子证书 ID。创建 HTTPS 监听器且证书来源为 pca_leaf 时必传。
        :param builtins.str san: 若实例支持自动选择扩展证书，即SniAutoMatch为on时，则Domain是空字符串。San为证书的扩展域名，用英文,分隔多个域名。
        """
        if cert_center_certificate_id is not None:
            pulumi.set(__self__, "cert_center_certificate_id", cert_center_certificate_id)
        if certificate_id is not None:
            pulumi.set(__self__, "certificate_id", certificate_id)
        if certificate_source is not None:
            pulumi.set(__self__, "certificate_source", certificate_source)
        if domain is not None:
            pulumi.set(__self__, "domain", domain)
        if pca_leaf_certificate_id is not None:
            pulumi.set(__self__, "pca_leaf_certificate_id", pca_leaf_certificate_id)
        if san is not None:
            pulumi.set(__self__, "san", san)

    @property
    @pulumi.getter(name="certCenterCertificateId")
    def cert_center_certificate_id(self) -> Optional[builtins.str]:
        """
        域名使用的服务器证书 ID 。当证书来源为 cert_center 时生效。
        """
        return pulumi.get(self, "cert_center_certificate_id")

    @property
    @pulumi.getter(name="certificateId")
    def certificate_id(self) -> Optional[builtins.str]:
        """
        域名使用的服务器证书 ID。当证书来源为 alb 时生效。
        """
        return pulumi.get(self, "certificate_id")

    @property
    @pulumi.getter(name="certificateSource")
    def certificate_source(self) -> Optional[builtins.str]:
        """
        域名使用的服务器证书的来源，取值：alb：表示通过 ALB 上传的证书。cert_center：表示通过火山引擎证书中心购买或上传的 SSL 证书。
        """
        return pulumi.get(self, "certificate_source")

    @property
    @pulumi.getter
    def domain(self) -> Optional[builtins.str]:
        """
        域名。通常不能为空，若实例支持自动选择扩展证书，即SniAutoMatch为on，则Domain需传入空字符串。需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含小写字、字、‘.’、‘-‘、‘*’。长度限制为1 ～ 128个字符。泛域名：使用“*”代替1个或多个字符。“*”必须在域名开头或结尾。同一条域名中“*”不能出现两次。“*”前后不能有除了.以外的字符。精确域名：符合域名规范的精确域名。同一HTTPS监听器下的域名不能重复。匹配域名时，对域名的大小写不敏感。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="pcaLeafCertificateId")
    def pca_leaf_certificate_id(self) -> Optional[builtins.str]:
        """
        HTTPS监听器关联的私有叶子证书 ID。创建 HTTPS 监听器且证书来源为 pca_leaf 时必传。
        """
        return pulumi.get(self, "pca_leaf_certificate_id")

    @property
    @pulumi.getter
    def san(self) -> Optional[builtins.str]:
        """
        若实例支持自动选择扩展证书，即SniAutoMatch为on时，则Domain是空字符串。San为证书的扩展域名，用英文,分隔多个域名。
        """
        return pulumi.get(self, "san")


@pulumi.output_type
class ListenerServerGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serverGroupId":
            suggest = "server_group_id"
        elif key == "serverGroupName":
            suggest = "server_group_name"

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

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

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

    def __init__(__self__, *,
                 server_group_id: Optional[builtins.str] = None,
                 server_group_name: Optional[builtins.str] = None):
        """
        :param builtins.str server_group_id: 服务器组 ID 。
        :param builtins.str server_group_name: 服务器组名称。
        """
        if server_group_id is not None:
            pulumi.set(__self__, "server_group_id", server_group_id)
        if server_group_name is not None:
            pulumi.set(__self__, "server_group_name", server_group_name)

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

    @property
    @pulumi.getter(name="serverGroupName")
    def server_group_name(self) -> Optional[builtins.str]:
        """
        服务器组名称。
        """
        return pulumi.get(self, "server_group_name")


@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个字符。大小写敏感。不能以volc:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        :param builtins.str value: 用户标签的标签值。具体规则如下：长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        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个字符。大小写敏感。不能以volc:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[builtins.str]:
        """
        用户标签的标签值。具体规则如下：长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class LoadBalancerEipBillingConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "billingType":
            suggest = "billing_type"

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

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

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

    def __init__(__self__, *,
                 bandwidth: Optional[builtins.int] = None,
                 billing_type: Optional[builtins.int] = None,
                 isp: Optional[builtins.str] = None):
        """
        :param builtins.int bandwidth: EIP的带宽峰值，单位为Mbps。
        :param builtins.int billing_type: EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param builtins.str isp: 公网IP的线路类型，BGP表示多线。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if billing_type is not None:
            pulumi.set(__self__, "billing_type", billing_type)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[builtins.int]:
        """
        EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> Optional[builtins.int]:
        """
        EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter
    def isp(self) -> Optional[builtins.str]:
        """
        公网IP的线路类型，BGP表示多线。
        """
        return pulumi.get(self, "isp")


@pulumi.output_type
class LoadBalancerGlobalAccelerator(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "acceleratorId":
            suggest = "accelerator_id"
        elif key == "acceleratorListenerId":
            suggest = "accelerator_listener_id"
        elif key == "endpointGroupId":
            suggest = "endpoint_group_id"

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

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

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

    def __init__(__self__, *,
                 accelerator_id: Optional[builtins.str] = None,
                 accelerator_listener_id: Optional[builtins.str] = None,
                 endpoint_group_id: Optional[builtins.str] = None,
                 weight: Optional[builtins.int] = None):
        """
        :param builtins.str accelerator_id: 绑定的全球加速实例的ID。
        :param builtins.str accelerator_listener_id: 绑定的全球加速监听器的ID。
        :param builtins.str endpoint_group_id: 绑定的终端节点组的ID。
        :param builtins.int weight: 后端服务器的权重，决定流量分发比例。
        """
        if accelerator_id is not None:
            pulumi.set(__self__, "accelerator_id", accelerator_id)
        if accelerator_listener_id is not None:
            pulumi.set(__self__, "accelerator_listener_id", accelerator_listener_id)
        if endpoint_group_id is not None:
            pulumi.set(__self__, "endpoint_group_id", endpoint_group_id)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="acceleratorId")
    def accelerator_id(self) -> Optional[builtins.str]:
        """
        绑定的全球加速实例的ID。
        """
        return pulumi.get(self, "accelerator_id")

    @property
    @pulumi.getter(name="acceleratorListenerId")
    def accelerator_listener_id(self) -> Optional[builtins.str]:
        """
        绑定的全球加速监听器的ID。
        """
        return pulumi.get(self, "accelerator_listener_id")

    @property
    @pulumi.getter(name="endpointGroupId")
    def endpoint_group_id(self) -> Optional[builtins.str]:
        """
        绑定的终端节点组的ID。
        """
        return pulumi.get(self, "endpoint_group_id")

    @property
    @pulumi.getter
    def weight(self) -> Optional[builtins.int]:
        """
        后端服务器的权重，决定流量分发比例。
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class LoadBalancerIpv6EipBillingConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "billingType":
            suggest = "billing_type"

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

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

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

    def __init__(__self__, *,
                 bandwidth: Optional[builtins.int] = None,
                 billing_type: Optional[builtins.int] = None,
                 isp: Optional[builtins.str] = None):
        """
        :param builtins.int bandwidth: IPv6 EIP的带宽峰值，单位为Mbps。
        :param builtins.int billing_type: IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param builtins.str isp: IPv6公网IP的线路类型，BGP表示多线。
        """
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if billing_type is not None:
            pulumi.set(__self__, "billing_type", billing_type)
        if isp is not None:
            pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[builtins.int]:
        """
        IPv6 EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> Optional[builtins.int]:
        """
        IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter
    def isp(self) -> Optional[builtins.str]:
        """
        IPv6公网IP的线路类型，BGP表示多线。
        """
        return pulumi.get(self, "isp")


@pulumi.output_type
class LoadBalancerTag(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 LoadBalancerZoneMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetId":
            suggest = "subnet_id"
        elif key == "zoneId":
            suggest = "zone_id"

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

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

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

    def __init__(__self__, *,
                 subnet_id: Optional[builtins.str] = None,
                 zone_id: Optional[builtins.str] = None):
        """
        :param builtins.str subnet_id: 可用区内提供服务的子网ID。
        :param builtins.str zone_id: 可用区的唯一标识符。
        """
        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="subnetId")
    def subnet_id(self) -> Optional[builtins.str]:
        """
        可用区内提供服务的子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[builtins.str]:
        """
        可用区的唯一标识符。
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class ServerGroupHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthyThreshold":
            suggest = "healthy_threshold"
        elif key == "httpCode":
            suggest = "http_code"
        elif key == "httpVersion":
            suggest = "http_version"
        elif key == "unhealthyThreshold":
            suggest = "unhealthy_threshold"

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

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

    def get(self, key: str, default = None) -> Any:
        ServerGroupHealthCheck.__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,
                 http_version: Optional[builtins.str] = None,
                 interval: Optional[builtins.int] = None,
                 method: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 protocol: Optional[builtins.str] = None,
                 timeout: Optional[builtins.int] = None,
                 unhealthy_threshold: Optional[builtins.int] = None,
                 uri: Optional[builtins.str] = None):
        """
        :param builtins.str domain: 健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。需至少包含一个‘.’，且不允许以‘.’开头或结尾。域名每一级由字母、数字、‘-’、‘.’字符组成，且‘-’不得出现在每一级的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示负载均衡使用各后端服务器的私网IP地址进行健康检查。
        :param builtins.str enabled: 监听器是否开启健康检查功能。取值：on：开启（默认值）。off：不开启。
        :param builtins.int healthy_threshold: 健康检查的健康阈值。表示连续执行指定次数的健康检查，结果均为正常的后端服务器将判定为健康检查正常。单位：次，取值：2~10，默认值为 3。
        :param builtins.str http_code: 健康检查正常的HTTP状态码，多个状态码间用半角逗号分隔。只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值如下：http*2xx（默认值）。http*3xx（默认值）。http*4xx 。http*5xx 。
        :param builtins.str http_version: 健康检查HTTP协议版本，只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值：HTTP1.0（使用API时，HTTP协议版本默认值）。HTTP1.1。
        :param builtins.int interval: 开启健康检查后，执行健康检查的时间间隔。 单位：秒，取值：1~300s，默认值为 2。
        :param builtins.str method: 开启健康检查后，健康检查的方法。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。取值如下：GET：服务器需支持GET方法。HEAD（默认）：服务器仅返回HEAD头部信息，可以降低后端性能消耗，但服务器需要支持HEAD方法。
        :param builtins.int port: 健康检查端口。支持取值：0（默认值）：使用后端服务器端口进行健康检查。1-65535：使用您指定的端口进行健康检查。
        :param builtins.str protocol: 健康检查协议，当前支持HTTP、TCP。默认值为 HTTP。
        :param builtins.int timeout: 健康检查的响应超时时间。表示如果后端服务器在指定的时间内没有正确响应，则判定为健康检查异常。单位：秒，取值：1~60，默认值为 2。
        :param builtins.int unhealthy_threshold: 健康检查的不健康阈值。表示连续执行指定次数的健康检查，结果均为异常的后端服务器将判定为健康检查异常。单位：次，取值：2~10，默认值为 3。
        :param builtins.str uri: 健康检查的路径，需配置为后端服务器上真实对外提供的路径。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。必须以字符‘/’开头。仅包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’ 字符。长度限制为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 http_version is not None:
            pulumi.set(__self__, "http_version", http_version)
        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 protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        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]:
        """
        健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。需至少包含一个‘.’，且不允许以‘.’开头或结尾。域名每一级由字母、数字、‘-’、‘.’字符组成，且‘-’不得出现在每一级的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示负载均衡使用各后端服务器的私网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状态码，多个状态码间用半角逗号分隔。只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值如下：http*2xx（默认值）。http*3xx（默认值）。http*4xx 。http*5xx 。
        """
        return pulumi.get(self, "http_code")

    @property
    @pulumi.getter(name="httpVersion")
    def http_version(self) -> Optional[builtins.str]:
        """
        健康检查HTTP协议版本，只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值：HTTP1.0（使用API时，HTTP协议版本默认值）。HTTP1.1。
        """
        return pulumi.get(self, "http_version")

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

    @property
    @pulumi.getter
    def method(self) -> Optional[builtins.str]:
        """
        开启健康检查后，健康检查的方法。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。取值如下：GET：服务器需支持GET方法。HEAD（默认）：服务器仅返回HEAD头部信息，可以降低后端性能消耗，但服务器需要支持HEAD方法。
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        健康检查端口。支持取值：0（默认值）：使用后端服务器端口进行健康检查。1-65535：使用您指定的端口进行健康检查。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[builtins.str]:
        """
        健康检查协议，当前支持HTTP、TCP。默认值为 HTTP。
        """
        return pulumi.get(self, "protocol")

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

    @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]:
        """
        健康检查的路径，需配置为后端服务器上真实对外提供的路径。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。必须以字符‘/’开头。仅包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’ 字符。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为“/”。
        """
        return pulumi.get(self, "uri")


@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"
        elif key == "remoteEnabled":
            suggest = "remote_enabled"
        elif key == "serverId":
            suggest = "server_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,
                 remote_enabled: Optional[builtins.str] = None,
                 server_id: Optional[builtins.str] = None,
                 type: Optional[builtins.str] = None,
                 weight: Optional[builtins.int] = None):
        """
        :param builtins.str description: 后端服务器的描述。
        :param builtins.str instance_id: 云服务器实例或网卡的ID。
        :param builtins.str ip: 后端服务器的私网IP地址。
        :param builtins.int port: 后端服务器接收请求的端口号。
        :param builtins.str remote_enabled: 是否开启远端IP功能。当后端服务器实例类型为IP地址，即 Type 取值为 ip 时，此字段有效。取值：on：开启。off（默认值）：不开启。
        :param builtins.str server_id: 后端服务器ID。
        :param builtins.str type: 后端服务器实例类型。ecs：云服务器实例。eni：辅助网卡。ip：IP地址（仅 Ip 类型服务器组有效）。
        :param builtins.int weight: 后端服务器的权重。
        """
        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 remote_enabled is not None:
            pulumi.set(__self__, "remote_enabled", remote_enabled)
        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)

    @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。
        """
        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="remoteEnabled")
    def remote_enabled(self) -> Optional[builtins.str]:
        """
        是否开启远端IP功能。当后端服务器实例类型为IP地址，即 Type 取值为 ip 时，此字段有效。取值：on：开启。off（默认值）：不开启。
        """
        return pulumi.get(self, "remote_enabled")

    @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地址（仅 Ip 类型服务器组有效）。
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class ServerGroupStickySessionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cookieTimeout":
            suggest = "cookie_timeout"
        elif key == "stickySessionEnabled":
            suggest = "sticky_session_enabled"
        elif key == "stickySessionType":
            suggest = "sticky_session_type"

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

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

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

    def __init__(__self__, *,
                 cookie: Optional[builtins.str] = None,
                 cookie_timeout: Optional[builtins.int] = None,
                 sticky_session_enabled: Optional[builtins.str] = None,
                 sticky_session_type: Optional[builtins.str] = None):
        """
        :param builtins.str cookie: 服务配置的会话保持 Cookie 名称。仅在开启会话保持功能并选择重写 Cookie 时有效。 具体规则如下：Cookie 名称长度为1~200个字符。名称只能包含 ASCII 英文字母和数字字符，不能包含半角逗号（,）、半角分号（;）或空格，也不能以美元符号（$）开头。当 tickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 server时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，该参数无效。
        :param builtins.int cookie_timeout: 会话保持 Cookie 超时时间。仅在开启会话保持功能并选择植入 Cookie 时有效。 单位：秒。具体规则如下：超时时间的取值范围：1～86400。 默认值为：1000。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionType 为 server 时，此参数无效。
        :param builtins.str sticky_session_enabled: 是否开启会话保持功能。on：开启；off（默认值）：关闭。
        :param builtins.str sticky_session_type: 对 Cookie 的处理方式。当 StickySessionConfig.StickySessionEnabled 值为 on 时，此字段参数必填。取值如下：insert：植入 Cookie；ALB 会记录客户端请求第一次转发到的后端服务器。ALB 在返回请求中植入 Cookie ，后续客户端请求携带此 Cookie，ALB 会将请求转发到之前记录的后端服务器上。server：重写 Cookie；开启重写 Cookie 的会话保持后，在客户端请求第一次转发到后端服务器后，ALB 在返回请求中发现您自定义的 Cookie 时，会对原来的 Cookie 进行重写。后续客户端请求携带改写后的 Cookie，ALB 会将请求转发到之前记录的后端服务器上。
        """
        if cookie is not None:
            pulumi.set(__self__, "cookie", cookie)
        if cookie_timeout is not None:
            pulumi.set(__self__, "cookie_timeout", cookie_timeout)
        if sticky_session_enabled is not None:
            pulumi.set(__self__, "sticky_session_enabled", sticky_session_enabled)
        if sticky_session_type is not None:
            pulumi.set(__self__, "sticky_session_type", sticky_session_type)

    @property
    @pulumi.getter
    def cookie(self) -> Optional[builtins.str]:
        """
        服务配置的会话保持 Cookie 名称。仅在开启会话保持功能并选择重写 Cookie 时有效。 具体规则如下：Cookie 名称长度为1~200个字符。名称只能包含 ASCII 英文字母和数字字符，不能包含半角逗号（,）、半角分号（;）或空格，也不能以美元符号（$）开头。当 tickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 server时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，该参数无效。
        """
        return pulumi.get(self, "cookie")

    @property
    @pulumi.getter(name="cookieTimeout")
    def cookie_timeout(self) -> Optional[builtins.int]:
        """
        会话保持 Cookie 超时时间。仅在开启会话保持功能并选择植入 Cookie 时有效。 单位：秒。具体规则如下：超时时间的取值范围：1～86400。 默认值为：1000。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionType 为 server 时，此参数无效。
        """
        return pulumi.get(self, "cookie_timeout")

    @property
    @pulumi.getter(name="stickySessionEnabled")
    def sticky_session_enabled(self) -> Optional[builtins.str]:
        """
        是否开启会话保持功能。on：开启；off（默认值）：关闭。
        """
        return pulumi.get(self, "sticky_session_enabled")

    @property
    @pulumi.getter(name="stickySessionType")
    def sticky_session_type(self) -> Optional[builtins.str]:
        """
        对 Cookie 的处理方式。当 StickySessionConfig.StickySessionEnabled 值为 on 时，此字段参数必填。取值如下：insert：植入 Cookie；ALB 会记录客户端请求第一次转发到的后端服务器。ALB 在返回请求中植入 Cookie ，后续客户端请求携带此 Cookie，ALB 会将请求转发到之前记录的后端服务器上。server：重写 Cookie；开启重写 Cookie 的会话保持后，在客户端请求第一次转发到后端服务器后，ALB 在返回请求中发现您自定义的 Cookie 时，会对原来的 Cookie 进行重写。后续客户端请求携带改写后的 Cookie，ALB 会将请求转发到之前记录的后端服务器上。
        """
        return pulumi.get(self, "sticky_session_type")


@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条目的描述。不能以http://或https://开头。必须以字母或中文开头，可包含数字、英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、短横线（-）、中文逗号（，）、中文句号（。） 。长度限制为1 ～ 255个字符。不填默认为空字符串。
        :param builtins.str entry: IP条目的地址段，只支持CIDR地址。
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "entry", entry)

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

    @property
    @pulumi.getter
    def entry(self) -> builtins.str:
        """
        IP条目的地址段，只支持CIDR地址。
        """
        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：白名单方式；black：黑名单方式
        :param builtins.str listener_id: 监听器的ID
        :param builtins.str listener_name: 监听器的名称
        :param builtins.int port: 监听器的端口
        :param builtins.str protocol: 监听器的协议
        """
        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：白名单方式；black：黑名单方式
        """
        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:
        """
        监听器的协议
        """
        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个字符。大小写敏感。不能以volc:和sys:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        :param builtins.str value: 用户标签的标签值。长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        用户标签的标签键。长度限制为1～128个字符。大小写敏感。不能以volc:和sys:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        用户标签的标签值。长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        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 GetListenerDomainExtensionResult(dict):
    def __init__(__self__, *,
                 cert_center_certificate_id: builtins.str,
                 certificate_id: builtins.str,
                 certificate_source: builtins.str,
                 domain: builtins.str,
                 domain_extension_id: builtins.str,
                 listener_id: builtins.str,
                 pca_leaf_certificate_id: builtins.str,
                 san: builtins.str):
        """
        :param builtins.str cert_center_certificate_id: 域名使用的服务器证书 ID 。当证书来源为 cert_center 时生效。
        :param builtins.str certificate_id: 域名使用的服务器证书 ID。当证书来源为 alb 时生效。
        :param builtins.str certificate_source: 域名使用的服务器证书的来源，取值：alb：表示通过 ALB 上传的证书。cert_center：表示通过火山引擎证书中心购买或上传的 SSL 证书。
        :param builtins.str domain: 域名。通常不能为空，若实例支持自动选择扩展证书，即SniAutoMatch为on，则Domain需传入空字符串。需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含小写字、字、‘.’、‘-‘、‘*’。长度限制为1 ～ 128个字符。泛域名：使用“*”代替1个或多个字符。“*”必须在域名开头或结尾。同一条域名中“*”不能出现两次。“*”前后不能有除了.以外的字符。精确域名：符合域名规范的精确域名。同一HTTPS监听器下的域名不能重复。匹配域名时，对域名的大小写不敏感。
        :param builtins.str domain_extension_id: 扩展域名 ID 。
        :param builtins.str listener_id: 扩展域名所属的监听器 ID。
        :param builtins.str pca_leaf_certificate_id: HTTPS监听器关联的私有叶子证书 ID。创建 HTTPS 监听器且证书来源为 pca_leaf 时必传。
        :param builtins.str san: 若实例支持自动选择扩展证书，即SniAutoMatch为on时，则Domain是空字符串。San为证书的扩展域名，用英文,分隔多个域名。
        """
        pulumi.set(__self__, "cert_center_certificate_id", cert_center_certificate_id)
        pulumi.set(__self__, "certificate_id", certificate_id)
        pulumi.set(__self__, "certificate_source", certificate_source)
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "domain_extension_id", domain_extension_id)
        pulumi.set(__self__, "listener_id", listener_id)
        pulumi.set(__self__, "pca_leaf_certificate_id", pca_leaf_certificate_id)
        pulumi.set(__self__, "san", san)

    @property
    @pulumi.getter(name="certCenterCertificateId")
    def cert_center_certificate_id(self) -> builtins.str:
        """
        域名使用的服务器证书 ID 。当证书来源为 cert_center 时生效。
        """
        return pulumi.get(self, "cert_center_certificate_id")

    @property
    @pulumi.getter(name="certificateId")
    def certificate_id(self) -> builtins.str:
        """
        域名使用的服务器证书 ID。当证书来源为 alb 时生效。
        """
        return pulumi.get(self, "certificate_id")

    @property
    @pulumi.getter(name="certificateSource")
    def certificate_source(self) -> builtins.str:
        """
        域名使用的服务器证书的来源，取值：alb：表示通过 ALB 上传的证书。cert_center：表示通过火山引擎证书中心购买或上传的 SSL 证书。
        """
        return pulumi.get(self, "certificate_source")

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        域名。通常不能为空，若实例支持自动选择扩展证书，即SniAutoMatch为on，则Domain需传入空字符串。需至少包含一个‘.’，且不允许以‘.’开头或结尾。仅允许包含小写字、字、‘.’、‘-‘、‘*’。长度限制为1 ～ 128个字符。泛域名：使用“*”代替1个或多个字符。“*”必须在域名开头或结尾。同一条域名中“*”不能出现两次。“*”前后不能有除了.以外的字符。精确域名：符合域名规范的精确域名。同一HTTPS监听器下的域名不能重复。匹配域名时，对域名的大小写不敏感。
        """
        return pulumi.get(self, "domain")

    @property
    @pulumi.getter(name="domainExtensionId")
    def domain_extension_id(self) -> builtins.str:
        """
        扩展域名 ID 。
        """
        return pulumi.get(self, "domain_extension_id")

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

    @property
    @pulumi.getter(name="pcaLeafCertificateId")
    def pca_leaf_certificate_id(self) -> builtins.str:
        """
        HTTPS监听器关联的私有叶子证书 ID。创建 HTTPS 监听器且证书来源为 pca_leaf 时必传。
        """
        return pulumi.get(self, "pca_leaf_certificate_id")

    @property
    @pulumi.getter
    def san(self) -> builtins.str:
        """
        若实例支持自动选择扩展证书，即SniAutoMatch为on时，则Domain是空字符串。San为证书的扩展域名，用英文,分隔多个域名。
        """
        return pulumi.get(self, "san")


@pulumi.output_type
class GetListenerServerGroupResult(dict):
    def __init__(__self__, *,
                 server_group_id: builtins.str,
                 server_group_name: builtins.str):
        """
        :param builtins.str server_group_id: 服务器组 ID 。
        :param builtins.str server_group_name: 服务器组名称。
        """
        pulumi.set(__self__, "server_group_id", server_group_id)
        pulumi.set(__self__, "server_group_name", server_group_name)

    @property
    @pulumi.getter(name="serverGroupId")
    def server_group_id(self) -> builtins.str:
        """
        服务器组 ID 。
        """
        return pulumi.get(self, "server_group_id")

    @property
    @pulumi.getter(name="serverGroupName")
    def server_group_name(self) -> builtins.str:
        """
        服务器组名称。
        """
        return pulumi.get(self, "server_group_name")


@pulumi.output_type
class GetListenerTagResult(dict):
    def __init__(__self__, *,
                 key: builtins.str,
                 value: builtins.str):
        """
        :param builtins.str key: 用户标签的标签键。具体规则如下：长度限制为1～128个字符。大小写敏感。不能以volc:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        :param builtins.str value: 用户标签的标签值。具体规则如下：长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> builtins.str:
        """
        用户标签的标签键。具体规则如下：长度限制为1～128个字符。大小写敏感。不能以volc:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> builtins.str:
        """
        用户标签的标签值。具体规则如下：长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class GetLoadBalancerEipBillingConfigResult(dict):
    def __init__(__self__, *,
                 bandwidth: builtins.int,
                 billing_type: builtins.int,
                 isp: builtins.str):
        """
        :param builtins.int bandwidth: EIP的带宽峰值，单位为Mbps。
        :param builtins.int billing_type: EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param builtins.str isp: 公网IP的线路类型，BGP表示多线。
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "billing_type", billing_type)
        pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def bandwidth(self) -> builtins.int:
        """
        EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> builtins.int:
        """
        EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter
    def isp(self) -> builtins.str:
        """
        公网IP的线路类型，BGP表示多线。
        """
        return pulumi.get(self, "isp")


@pulumi.output_type
class GetLoadBalancerGlobalAcceleratorResult(dict):
    def __init__(__self__, *,
                 accelerator_id: builtins.str,
                 accelerator_listener_id: builtins.str,
                 endpoint_group_id: builtins.str,
                 weight: builtins.int):
        """
        :param builtins.str accelerator_id: 绑定的全球加速实例的ID。
        :param builtins.str accelerator_listener_id: 绑定的全球加速监听器的ID。
        :param builtins.str endpoint_group_id: 绑定的终端节点组的ID。
        :param builtins.int weight: 后端服务器的权重，决定流量分发比例。
        """
        pulumi.set(__self__, "accelerator_id", accelerator_id)
        pulumi.set(__self__, "accelerator_listener_id", accelerator_listener_id)
        pulumi.set(__self__, "endpoint_group_id", endpoint_group_id)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="acceleratorId")
    def accelerator_id(self) -> builtins.str:
        """
        绑定的全球加速实例的ID。
        """
        return pulumi.get(self, "accelerator_id")

    @property
    @pulumi.getter(name="acceleratorListenerId")
    def accelerator_listener_id(self) -> builtins.str:
        """
        绑定的全球加速监听器的ID。
        """
        return pulumi.get(self, "accelerator_listener_id")

    @property
    @pulumi.getter(name="endpointGroupId")
    def endpoint_group_id(self) -> builtins.str:
        """
        绑定的终端节点组的ID。
        """
        return pulumi.get(self, "endpoint_group_id")

    @property
    @pulumi.getter
    def weight(self) -> builtins.int:
        """
        后端服务器的权重，决定流量分发比例。
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetLoadBalancerIpv6EipBillingConfigResult(dict):
    def __init__(__self__, *,
                 bandwidth: builtins.int,
                 billing_type: builtins.int,
                 isp: builtins.str):
        """
        :param builtins.int bandwidth: IPv6 EIP的带宽峰值，单位为Mbps。
        :param builtins.int billing_type: IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param builtins.str isp: IPv6公网IP的线路类型，BGP表示多线。
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "billing_type", billing_type)
        pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def bandwidth(self) -> builtins.int:
        """
        IPv6 EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> builtins.int:
        """
        IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter
    def isp(self) -> builtins.str:
        """
        IPv6公网IP的线路类型，BGP表示多线。
        """
        return pulumi.get(self, "isp")


@pulumi.output_type
class GetLoadBalancerTagResult(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 GetLoadBalancerZoneMappingResult(dict):
    def __init__(__self__, *,
                 load_balancer_addresses: Sequence['outputs.GetLoadBalancerZoneMappingLoadBalancerAddressResult'],
                 subnet_id: builtins.str,
                 zone_id: builtins.str):
        """
        :param Sequence['GetLoadBalancerZoneMappingLoadBalancerAddressArgs'] load_balancer_addresses: 该可用区下负载均衡提供的IP地址列表。
        :param builtins.str subnet_id: 可用区内提供服务的子网ID。
        :param builtins.str zone_id: 可用区的唯一标识符。
        """
        pulumi.set(__self__, "load_balancer_addresses", load_balancer_addresses)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="loadBalancerAddresses")
    def load_balancer_addresses(self) -> Sequence['outputs.GetLoadBalancerZoneMappingLoadBalancerAddressResult']:
        """
        该可用区下负载均衡提供的IP地址列表。
        """
        return pulumi.get(self, "load_balancer_addresses")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> builtins.str:
        """
        可用区内提供服务的子网ID。
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> builtins.str:
        """
        可用区的唯一标识符。
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class GetLoadBalancerZoneMappingLoadBalancerAddressResult(dict):
    def __init__(__self__, *,
                 eip: 'outputs.GetLoadBalancerZoneMappingLoadBalancerAddressEipResult',
                 eip_address: builtins.str,
                 eip_id: builtins.str,
                 eni_address: builtins.str,
                 eni_id: builtins.str,
                 eni_ipv6_address: builtins.str,
                 ipv6_eip: 'outputs.GetLoadBalancerZoneMappingLoadBalancerAddressIpv6EipResult',
                 ipv6_eip_id: builtins.str):
        """
        :param 'GetLoadBalancerZoneMappingLoadBalancerAddressEipArgs' eip: 弹性公网IP（EIP）的详细信息。
        :param builtins.str eip_address: 绑定的弹性公网IP（EIP）的地址。
        :param builtins.str eip_id: 绑定的弹性公网IP（EIP）的ID。
        :param builtins.str eni_address: 弹性网卡（ENI）上的私网IP地址。
        :param builtins.str eni_id: IP地址所属的弹性网卡（ENI）的ID。
        :param builtins.str eni_ipv6_address: 弹性网卡（ENI）上的IPv6私网地址。
        :param 'GetLoadBalancerZoneMappingLoadBalancerAddressIpv6EipArgs' ipv6_eip: IPv6弹性公网IP的详细信息。
        :param builtins.str ipv6_eip_id: 绑定的IPv6 EIP的ID。
        """
        pulumi.set(__self__, "eip", eip)
        pulumi.set(__self__, "eip_address", eip_address)
        pulumi.set(__self__, "eip_id", eip_id)
        pulumi.set(__self__, "eni_address", eni_address)
        pulumi.set(__self__, "eni_id", eni_id)
        pulumi.set(__self__, "eni_ipv6_address", eni_ipv6_address)
        pulumi.set(__self__, "ipv6_eip", ipv6_eip)
        pulumi.set(__self__, "ipv6_eip_id", ipv6_eip_id)

    @property
    @pulumi.getter
    def eip(self) -> 'outputs.GetLoadBalancerZoneMappingLoadBalancerAddressEipResult':
        """
        弹性公网IP（EIP）的详细信息。
        """
        return pulumi.get(self, "eip")

    @property
    @pulumi.getter(name="eipAddress")
    def eip_address(self) -> builtins.str:
        """
        绑定的弹性公网IP（EIP）的地址。
        """
        return pulumi.get(self, "eip_address")

    @property
    @pulumi.getter(name="eipId")
    def eip_id(self) -> builtins.str:
        """
        绑定的弹性公网IP（EIP）的ID。
        """
        return pulumi.get(self, "eip_id")

    @property
    @pulumi.getter(name="eniAddress")
    def eni_address(self) -> builtins.str:
        """
        弹性网卡（ENI）上的私网IP地址。
        """
        return pulumi.get(self, "eni_address")

    @property
    @pulumi.getter(name="eniId")
    def eni_id(self) -> builtins.str:
        """
        IP地址所属的弹性网卡（ENI）的ID。
        """
        return pulumi.get(self, "eni_id")

    @property
    @pulumi.getter(name="eniIpv6Address")
    def eni_ipv6_address(self) -> builtins.str:
        """
        弹性网卡（ENI）上的IPv6私网地址。
        """
        return pulumi.get(self, "eni_ipv6_address")

    @property
    @pulumi.getter(name="ipv6Eip")
    def ipv6_eip(self) -> 'outputs.GetLoadBalancerZoneMappingLoadBalancerAddressIpv6EipResult':
        """
        IPv6弹性公网IP的详细信息。
        """
        return pulumi.get(self, "ipv6_eip")

    @property
    @pulumi.getter(name="ipv6EipId")
    def ipv6_eip_id(self) -> builtins.str:
        """
        绑定的IPv6 EIP的ID。
        """
        return pulumi.get(self, "ipv6_eip_id")


@pulumi.output_type
class GetLoadBalancerZoneMappingLoadBalancerAddressEipResult(dict):
    def __init__(__self__, *,
                 association_mode: builtins.str,
                 bandwidth: builtins.int,
                 eip_address: builtins.str,
                 eip_billing_type: builtins.int,
                 eip_type: builtins.str,
                 isp: builtins.str,
                 pop_locations: Sequence['outputs.GetLoadBalancerZoneMappingLoadBalancerAddressEipPopLocationResult']):
        """
        :param builtins.str association_mode: EIP的绑定模式，例如Default或Normal。
        :param builtins.int bandwidth: EIP的带宽峰值，单位为Mbps。
        :param builtins.str eip_address: 弹性公网IP（EIP）的地址。
        :param builtins.int eip_billing_type: EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param builtins.str eip_type: EIP的类型，例如静态BGP。
        :param builtins.str isp: 公网IP的线路类型，BGP表示多线。
        :param Sequence['GetLoadBalancerZoneMappingLoadBalancerAddressEipPopLocationArgs'] pop_locations: EIP的接入点位置信息列表。
        """
        pulumi.set(__self__, "association_mode", association_mode)
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "eip_address", eip_address)
        pulumi.set(__self__, "eip_billing_type", eip_billing_type)
        pulumi.set(__self__, "eip_type", eip_type)
        pulumi.set(__self__, "isp", isp)
        pulumi.set(__self__, "pop_locations", pop_locations)

    @property
    @pulumi.getter(name="associationMode")
    def association_mode(self) -> builtins.str:
        """
        EIP的绑定模式，例如Default或Normal。
        """
        return pulumi.get(self, "association_mode")

    @property
    @pulumi.getter
    def bandwidth(self) -> builtins.int:
        """
        EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="eipAddress")
    def eip_address(self) -> builtins.str:
        """
        弹性公网IP（EIP）的地址。
        """
        return pulumi.get(self, "eip_address")

    @property
    @pulumi.getter(name="eipBillingType")
    def eip_billing_type(self) -> builtins.int:
        """
        EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        return pulumi.get(self, "eip_billing_type")

    @property
    @pulumi.getter(name="eipType")
    def eip_type(self) -> builtins.str:
        """
        EIP的类型，例如静态BGP。
        """
        return pulumi.get(self, "eip_type")

    @property
    @pulumi.getter
    def isp(self) -> builtins.str:
        """
        公网IP的线路类型，BGP表示多线。
        """
        return pulumi.get(self, "isp")

    @property
    @pulumi.getter(name="popLocations")
    def pop_locations(self) -> Sequence['outputs.GetLoadBalancerZoneMappingLoadBalancerAddressEipPopLocationResult']:
        """
        EIP的接入点位置信息列表。
        """
        return pulumi.get(self, "pop_locations")


@pulumi.output_type
class GetLoadBalancerZoneMappingLoadBalancerAddressEipPopLocationResult(dict):
    def __init__(__self__, *,
                 pop_id: builtins.str,
                 pop_name: builtins.str):
        """
        :param builtins.str pop_id: 接入点（PoP）的唯一ID。
        :param builtins.str pop_name: 接入点（PoP）的名称。
        """
        pulumi.set(__self__, "pop_id", pop_id)
        pulumi.set(__self__, "pop_name", pop_name)

    @property
    @pulumi.getter(name="popId")
    def pop_id(self) -> builtins.str:
        """
        接入点（PoP）的唯一ID。
        """
        return pulumi.get(self, "pop_id")

    @property
    @pulumi.getter(name="popName")
    def pop_name(self) -> builtins.str:
        """
        接入点（PoP）的名称。
        """
        return pulumi.get(self, "pop_name")


@pulumi.output_type
class GetLoadBalancerZoneMappingLoadBalancerAddressIpv6EipResult(dict):
    def __init__(__self__, *,
                 bandwidth: builtins.int,
                 billing_type: builtins.int,
                 isp: builtins.str):
        """
        :param builtins.int bandwidth: IPv6 EIP的带宽峰值，单位为Mbps。
        :param builtins.int billing_type: IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param builtins.str isp: IPv6公网IP的线路类型，BGP表示多线。
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "billing_type", billing_type)
        pulumi.set(__self__, "isp", isp)

    @property
    @pulumi.getter
    def bandwidth(self) -> builtins.int:
        """
        IPv6 EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="billingType")
    def billing_type(self) -> builtins.int:
        """
        IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        return pulumi.get(self, "billing_type")

    @property
    @pulumi.getter
    def isp(self) -> builtins.str:
        """
        IPv6公网IP的线路类型，BGP表示多线。
        """
        return pulumi.get(self, "isp")


@pulumi.output_type
class GetServerGroupHealthCheckResult(dict):
    def __init__(__self__, *,
                 domain: builtins.str,
                 enabled: builtins.str,
                 healthy_threshold: builtins.int,
                 http_code: builtins.str,
                 http_version: builtins.str,
                 interval: builtins.int,
                 method: builtins.str,
                 port: builtins.int,
                 protocol: builtins.str,
                 timeout: builtins.int,
                 unhealthy_threshold: builtins.int,
                 uri: builtins.str):
        """
        :param builtins.str domain: 健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。需至少包含一个‘.’，且不允许以‘.’开头或结尾。域名每一级由字母、数字、‘-’、‘.’字符组成，且‘-’不得出现在每一级的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示负载均衡使用各后端服务器的私网IP地址进行健康检查。
        :param builtins.str enabled: 监听器是否开启健康检查功能。取值：on：开启（默认值）。off：不开启。
        :param builtins.int healthy_threshold: 健康检查的健康阈值。表示连续执行指定次数的健康检查，结果均为正常的后端服务器将判定为健康检查正常。单位：次，取值：2~10，默认值为 3。
        :param builtins.str http_code: 健康检查正常的HTTP状态码，多个状态码间用半角逗号分隔。只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值如下：http*2xx（默认值）。http*3xx（默认值）。http*4xx 。http*5xx 。
        :param builtins.str http_version: 健康检查HTTP协议版本，只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值：HTTP1.0（使用API时，HTTP协议版本默认值）。HTTP1.1。
        :param builtins.int interval: 开启健康检查后，执行健康检查的时间间隔。 单位：秒，取值：1~300s，默认值为 2。
        :param builtins.str method: 开启健康检查后，健康检查的方法。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。取值如下：GET：服务器需支持GET方法。HEAD（默认）：服务器仅返回HEAD头部信息，可以降低后端性能消耗，但服务器需要支持HEAD方法。
        :param builtins.int port: 健康检查端口。支持取值：0（默认值）：使用后端服务器端口进行健康检查。1-65535：使用您指定的端口进行健康检查。
        :param builtins.str protocol: 健康检查协议，当前支持HTTP、TCP。默认值为 HTTP。
        :param builtins.int timeout: 健康检查的响应超时时间。表示如果后端服务器在指定的时间内没有正确响应，则判定为健康检查异常。单位：秒，取值：1~60，默认值为 2。
        :param builtins.int unhealthy_threshold: 健康检查的不健康阈值。表示连续执行指定次数的健康检查，结果均为异常的后端服务器将判定为健康检查异常。单位：次，取值：2~10，默认值为 3。
        :param builtins.str uri: 健康检查的路径，需配置为后端服务器上真实对外提供的路径。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。必须以字符‘/’开头。仅包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’ 字符。长度限制为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__, "http_version", http_version)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "method", method)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "timeout", timeout)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def domain(self) -> builtins.str:
        """
        健康检查的域名，需配置为后端服务器上真实对外提供服务的地址。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。需至少包含一个‘.’，且不允许以‘.’开头或结尾。域名每一级由字母、数字、‘-’、‘.’字符组成，且‘-’不得出现在每一级的头部或尾部。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为空，表示负载均衡使用各后端服务器的私网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状态码，多个状态码间用半角逗号分隔。只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值如下：http*2xx（默认值）。http*3xx（默认值）。http*4xx 。http*5xx 。
        """
        return pulumi.get(self, "http_code")

    @property
    @pulumi.getter(name="httpVersion")
    def http_version(self) -> builtins.str:
        """
        健康检查HTTP协议版本，只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值：HTTP1.0（使用API时，HTTP协议版本默认值）。HTTP1.1。
        """
        return pulumi.get(self, "http_version")

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

    @property
    @pulumi.getter
    def method(self) -> builtins.str:
        """
        开启健康检查后，健康检查的方法。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。取值如下：GET：服务器需支持GET方法。HEAD（默认）：服务器仅返回HEAD头部信息，可以降低后端性能消耗，但服务器需要支持HEAD方法。
        """
        return pulumi.get(self, "method")

    @property
    @pulumi.getter
    def port(self) -> builtins.int:
        """
        健康检查端口。支持取值：0（默认值）：使用后端服务器端口进行健康检查。1-65535：使用您指定的端口进行健康检查。
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> builtins.str:
        """
        健康检查协议，当前支持HTTP、TCP。默认值为 HTTP。
        """
        return pulumi.get(self, "protocol")

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

    @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:
        """
        健康检查的路径，需配置为后端服务器上真实对外提供的路径。只有 HealthCheck.Protocol 设置为 HTTP 时该参数生效。必须以字符‘/’开头。仅包含字母、数字、‘-’、‘_’、‘/’、‘.’、‘%’、‘?’、‘#’、‘&’、‘＝’ 字符。长度限制为1 ～ 128个字符。不传入该参数或该参数不传入数值时，默认为“/”。
        """
        return pulumi.get(self, "uri")


@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__, *,
                 description: builtins.str,
                 instance_id: builtins.str,
                 ip: builtins.str,
                 port: builtins.int,
                 remote_enabled: builtins.str,
                 server_id: builtins.str,
                 type: builtins.str,
                 weight: builtins.int):
        """
        :param builtins.str description: 后端服务器的描述。
        :param builtins.str instance_id: 云服务器实例或网卡的ID。
        :param builtins.str ip: 后端服务器的私网IP地址。
        :param builtins.int port: 后端服务器接收请求的端口号。
        :param builtins.str remote_enabled: 是否开启远端IP功能。当后端服务器实例类型为IP地址，即 Type 取值为 ip 时，此字段有效。取值：on：开启。off（默认值）：不开启。
        :param builtins.str server_id: 后端服务器ID。
        :param builtins.str type: 后端服务器实例类型。ecs：云服务器实例。eni：辅助网卡。ip：IP地址（仅 Ip 类型服务器组有效）。
        :param builtins.int weight: 后端服务器的权重。
        """
        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__, "remote_enabled", remote_enabled)
        pulumi.set(__self__, "server_id", server_id)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)

    @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。
        """
        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="remoteEnabled")
    def remote_enabled(self) -> builtins.str:
        """
        是否开启远端IP功能。当后端服务器实例类型为IP地址，即 Type 取值为 ip 时，此字段有效。取值：on：开启。off（默认值）：不开启。
        """
        return pulumi.get(self, "remote_enabled")

    @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地址（仅 Ip 类型服务器组有效）。
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> builtins.int:
        """
        后端服务器的权重。
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetServerGroupStickySessionConfigResult(dict):
    def __init__(__self__, *,
                 cookie: builtins.str,
                 cookie_timeout: builtins.int,
                 sticky_session_enabled: builtins.str,
                 sticky_session_type: builtins.str):
        """
        :param builtins.str cookie: 服务配置的会话保持 Cookie 名称。仅在开启会话保持功能并选择重写 Cookie 时有效。 具体规则如下：Cookie 名称长度为1~200个字符。名称只能包含 ASCII 英文字母和数字字符，不能包含半角逗号（,）、半角分号（;）或空格，也不能以美元符号（$）开头。当 tickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 server时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，该参数无效。
        :param builtins.int cookie_timeout: 会话保持 Cookie 超时时间。仅在开启会话保持功能并选择植入 Cookie 时有效。 单位：秒。具体规则如下：超时时间的取值范围：1～86400。 默认值为：1000。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionType 为 server 时，此参数无效。
        :param builtins.str sticky_session_enabled: 是否开启会话保持功能。on：开启；off（默认值）：关闭。
        :param builtins.str sticky_session_type: 对 Cookie 的处理方式。当 StickySessionConfig.StickySessionEnabled 值为 on 时，此字段参数必填。取值如下：insert：植入 Cookie；ALB 会记录客户端请求第一次转发到的后端服务器。ALB 在返回请求中植入 Cookie ，后续客户端请求携带此 Cookie，ALB 会将请求转发到之前记录的后端服务器上。server：重写 Cookie；开启重写 Cookie 的会话保持后，在客户端请求第一次转发到后端服务器后，ALB 在返回请求中发现您自定义的 Cookie 时，会对原来的 Cookie 进行重写。后续客户端请求携带改写后的 Cookie，ALB 会将请求转发到之前记录的后端服务器上。
        """
        pulumi.set(__self__, "cookie", cookie)
        pulumi.set(__self__, "cookie_timeout", cookie_timeout)
        pulumi.set(__self__, "sticky_session_enabled", sticky_session_enabled)
        pulumi.set(__self__, "sticky_session_type", sticky_session_type)

    @property
    @pulumi.getter
    def cookie(self) -> builtins.str:
        """
        服务配置的会话保持 Cookie 名称。仅在开启会话保持功能并选择重写 Cookie 时有效。 具体规则如下：Cookie 名称长度为1~200个字符。名称只能包含 ASCII 英文字母和数字字符，不能包含半角逗号（,）、半角分号（;）或空格，也不能以美元符号（$）开头。当 tickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 server时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，该参数无效。
        """
        return pulumi.get(self, "cookie")

    @property
    @pulumi.getter(name="cookieTimeout")
    def cookie_timeout(self) -> builtins.int:
        """
        会话保持 Cookie 超时时间。仅在开启会话保持功能并选择植入 Cookie 时有效。 单位：秒。具体规则如下：超时时间的取值范围：1～86400。 默认值为：1000。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionType 为 server 时，此参数无效。
        """
        return pulumi.get(self, "cookie_timeout")

    @property
    @pulumi.getter(name="stickySessionEnabled")
    def sticky_session_enabled(self) -> builtins.str:
        """
        是否开启会话保持功能。on：开启；off（默认值）：关闭。
        """
        return pulumi.get(self, "sticky_session_enabled")

    @property
    @pulumi.getter(name="stickySessionType")
    def sticky_session_type(self) -> builtins.str:
        """
        对 Cookie 的处理方式。当 StickySessionConfig.StickySessionEnabled 值为 on 时，此字段参数必填。取值如下：insert：植入 Cookie；ALB 会记录客户端请求第一次转发到的后端服务器。ALB 在返回请求中植入 Cookie ，后续客户端请求携带此 Cookie，ALB 会将请求转发到之前记录的后端服务器上。server：重写 Cookie；开启重写 Cookie 的会话保持后，在客户端请求第一次转发到后端服务器后，ALB 在返回请求中发现您自定义的 Cookie 时，会对原来的 Cookie 进行重写。后续客户端请求携带改写后的 Cookie，ALB 会将请求转发到之前记录的后端服务器上。
        """
        return pulumi.get(self, "sticky_session_type")


@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")


