# 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__ = [
    'AclAclEntryArgs',
    'AclAclEntryArgsDict',
    'AclListenerArgs',
    'AclListenerArgsDict',
    'AclTagArgs',
    'AclTagArgsDict',
    'CertificateTagArgs',
    'CertificateTagArgsDict',
    'ListenerDomainExtensionArgs',
    'ListenerDomainExtensionArgsDict',
    'ListenerServerGroupArgs',
    'ListenerServerGroupArgsDict',
    'ListenerTagArgs',
    'ListenerTagArgsDict',
    'LoadBalancerEipBillingConfigArgs',
    'LoadBalancerEipBillingConfigArgsDict',
    'LoadBalancerGlobalAcceleratorArgs',
    'LoadBalancerGlobalAcceleratorArgsDict',
    'LoadBalancerIpv6EipBillingConfigArgs',
    'LoadBalancerIpv6EipBillingConfigArgsDict',
    'LoadBalancerTagArgs',
    'LoadBalancerTagArgsDict',
    'LoadBalancerZoneMappingArgs',
    'LoadBalancerZoneMappingArgsDict',
    'ServerGroupHealthCheckArgs',
    'ServerGroupHealthCheckArgsDict',
    'ServerGroupListenerArgs',
    'ServerGroupListenerArgsDict',
    'ServerGroupServerArgs',
    'ServerGroupServerArgsDict',
    'ServerGroupStickySessionConfigArgs',
    'ServerGroupStickySessionConfigArgsDict',
    'ServerGroupTagArgs',
    'ServerGroupTagArgsDict',
]

MYPY = False

if not MYPY:
    class AclAclEntryArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        IP条目的描述。不能以http://或https://开头。必须以字母或中文开头，可包含数字、英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、短横线（-）、中文逗号（，）、中文句号（。） 。长度限制为1 ～ 255个字符。不填默认为空字符串。
        """
        entry: NotRequired[pulumi.Input[builtins.str]]
        """
        IP条目的地址段，只支持CIDR地址。
        """
elif False:
    AclAclEntryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AclAclEntryArgs:
    def __init__(__self__, *,
                 description: Optional[pulumi.Input[builtins.str]] = None,
                 entry: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] description: IP条目的描述。不能以http://或https://开头。必须以字母或中文开头，可包含数字、英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、短横线（-）、中文逗号（，）、中文句号（。） 。长度限制为1 ～ 255个字符。不填默认为空字符串。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        IP条目的描述。不能以http://或https://开头。必须以字母或中文开头，可包含数字、英文逗号（,）、点号（.）、下划线（_）、空格（ ）、等号（=）、短横线（-）、中文逗号（，）、中文句号（。） 。长度限制为1 ～ 255个字符。不填默认为空字符串。
        """
        return pulumi.get(self, "description")

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

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

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


if not MYPY:
    class AclListenerArgsDict(TypedDict):
        acl_type: NotRequired[pulumi.Input[builtins.str]]
        """
        监听器对本访问控制策略组的控制方式。white：白名单方式；black：黑名单方式
        """
elif False:
    AclListenerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AclListenerArgs:
    def __init__(__self__, *,
                 acl_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        监听器对本访问控制策略组的控制方式。white：白名单方式；black：黑名单方式
        """
        return pulumi.get(self, "acl_type")

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


if not MYPY:
    class AclTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签键。长度限制为1～128个字符。大小写敏感。不能以volc:和sys:的任意大小写组合开头。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。同一资源的标签键不允许重复。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签值。长度限制为0～256个字符。大小写敏感。不能以空格开头或结尾。允许包含各国语言文字、数字、空格（）、下划线（_）、点号（.）、半角冒号（:）、斜杠（/）、等号（=）、加号（+）、减号（-）和@。
        """
elif False:
    AclTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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


if not MYPY:
    class CertificateTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签键。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        用户标签的标签值。
        """
elif False:
    CertificateTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CertificateTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 用户标签的标签键。
        :param pulumi.Input[builtins.str] value: 用户标签的标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class ListenerServerGroupArgsDict(TypedDict):
        server_group_id: NotRequired[pulumi.Input[builtins.str]]
        """
        服务器组 ID 。
        """
        server_group_name: NotRequired[pulumi.Input[builtins.str]]
        """
        服务器组名称。
        """
elif False:
    ListenerServerGroupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ListenerServerGroupArgs:
    def __init__(__self__, *,
                 server_group_id: Optional[pulumi.Input[builtins.str]] = None,
                 server_group_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] server_group_id: 服务器组 ID 。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        服务器组 ID 。
        """
        return pulumi.get(self, "server_group_id")

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

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

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


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

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

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

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

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


if not MYPY:
    class LoadBalancerEipBillingConfigArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        EIP的带宽峰值，单位为Mbps。
        """
        billing_type: NotRequired[pulumi.Input[builtins.int]]
        """
        EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        isp: NotRequired[pulumi.Input[builtins.str]]
        """
        公网IP的线路类型，BGP表示多线。
        """
elif False:
    LoadBalancerEipBillingConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LoadBalancerEipBillingConfigArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 billing_type: Optional[pulumi.Input[builtins.int]] = None,
                 isp: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: EIP的带宽峰值，单位为Mbps。
        :param pulumi.Input[builtins.int] billing_type: EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

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

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

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

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

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


if not MYPY:
    class LoadBalancerGlobalAcceleratorArgsDict(TypedDict):
        accelerator_id: NotRequired[pulumi.Input[builtins.str]]
        """
        绑定的全球加速实例的ID。
        """
        accelerator_listener_id: NotRequired[pulumi.Input[builtins.str]]
        """
        绑定的全球加速监听器的ID。
        """
        endpoint_group_id: NotRequired[pulumi.Input[builtins.str]]
        """
        绑定的终端节点组的ID。
        """
        weight: NotRequired[pulumi.Input[builtins.int]]
        """
        后端服务器的权重，决定流量分发比例。
        """
elif False:
    LoadBalancerGlobalAcceleratorArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LoadBalancerGlobalAcceleratorArgs:
    def __init__(__self__, *,
                 accelerator_id: Optional[pulumi.Input[builtins.str]] = None,
                 accelerator_listener_id: Optional[pulumi.Input[builtins.str]] = None,
                 endpoint_group_id: Optional[pulumi.Input[builtins.str]] = None,
                 weight: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.str] accelerator_id: 绑定的全球加速实例的ID。
        :param pulumi.Input[builtins.str] accelerator_listener_id: 绑定的全球加速监听器的ID。
        :param pulumi.Input[builtins.str] endpoint_group_id: 绑定的终端节点组的ID。
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        绑定的全球加速实例的ID。
        """
        return pulumi.get(self, "accelerator_id")

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

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

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

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

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

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

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


if not MYPY:
    class LoadBalancerIpv6EipBillingConfigArgsDict(TypedDict):
        bandwidth: NotRequired[pulumi.Input[builtins.int]]
        """
        IPv6 EIP的带宽峰值，单位为Mbps。
        """
        billing_type: NotRequired[pulumi.Input[builtins.int]]
        """
        IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        """
        isp: NotRequired[pulumi.Input[builtins.str]]
        """
        IPv6公网IP的线路类型，BGP表示多线。
        """
elif False:
    LoadBalancerIpv6EipBillingConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LoadBalancerIpv6EipBillingConfigArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[builtins.int]] = None,
                 billing_type: Optional[pulumi.Input[builtins.int]] = None,
                 isp: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.int] bandwidth: IPv6 EIP的带宽峰值，单位为Mbps。
        :param pulumi.Input[builtins.int] billing_type: IPv6 EIP的计费方式，2为按带宽计费，3为按流量计费。
        :param pulumi.Input[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[pulumi.Input[builtins.int]]:
        """
        IPv6 EIP的带宽峰值，单位为Mbps。
        """
        return pulumi.get(self, "bandwidth")

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

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

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

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

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


if not MYPY:
    class LoadBalancerTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签的键，用于标识标签的类别。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签的值，用于标识具体的标签内容。
        """
elif False:
    LoadBalancerTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LoadBalancerTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签的键，用于标识标签的类别。
        :param pulumi.Input[builtins.str] value: 标签的值，用于标识具体的标签内容。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签的键，用于标识标签的类别。
        """
        return pulumi.get(self, "key")

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签的值，用于标识具体的标签内容。
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class LoadBalancerZoneMappingArgsDict(TypedDict):
        subnet_id: NotRequired[pulumi.Input[builtins.str]]
        """
        可用区内提供服务的子网ID。
        """
        zone_id: NotRequired[pulumi.Input[builtins.str]]
        """
        可用区的唯一标识符。
        """
elif False:
    LoadBalancerZoneMappingArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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


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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="httpCode")
    def http_code(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        健康检查正常的HTTP状态码，多个状态码间用半角逗号分隔。只有 HealthCheck.Protocol 为 HTTP 时才存在该参数。取值如下：http*2xx（默认值）。http*3xx（默认值）。http*4xx 。http*5xx 。
        """
        return pulumi.get(self, "http_code")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class ServerGroupListenerArgsDict(TypedDict):
        listener_id: NotRequired[pulumi.Input[builtins.str]]
        """
        监听器的ID。
        """
elif False:
    ServerGroupListenerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerGroupListenerArgs:
    def __init__(__self__, *,
                 listener_id: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[builtins.str]]:
        """
        监听器的ID。
        """
        return pulumi.get(self, "listener_id")

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


if not MYPY:
    class ServerGroupServerArgsDict(TypedDict):
        description: NotRequired[pulumi.Input[builtins.str]]
        """
        后端服务器的描述。
        """
        instance_id: NotRequired[pulumi.Input[builtins.str]]
        """
        云服务器实例或网卡的ID。
        """
        ip: NotRequired[pulumi.Input[builtins.str]]
        """
        后端服务器的私网IP地址。
        """
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        后端服务器接收请求的端口号。
        """
        remote_enabled: NotRequired[pulumi.Input[builtins.str]]
        """
        是否开启远端IP功能。当后端服务器实例类型为IP地址，即 Type 取值为 ip 时，此字段有效。取值：on：开启。off（默认值）：不开启。
        """
        server_id: NotRequired[pulumi.Input[builtins.str]]
        """
        后端服务器ID。
        """
        type: NotRequired[pulumi.Input[builtins.str]]
        """
        后端服务器实例类型。ecs：云服务器实例。eni：辅助网卡。ip：IP地址（仅 Ip 类型服务器组有效）。
        """
        weight: NotRequired[pulumi.Input[builtins.int]]
        """
        后端服务器的权重。
        """
elif False:
    ServerGroupServerArgsDict: TypeAlias = Mapping[str, Any]

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

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

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        云服务器实例或网卡的ID。
        """
        return pulumi.get(self, "instance_id")

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

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

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

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        后端服务器接收请求的端口号。
        """
        return pulumi.get(self, "port")

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

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

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

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

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        后端服务器实例类型。ecs：云服务器实例。eni：辅助网卡。ip：IP地址（仅 Ip 类型服务器组有效）。
        """
        return pulumi.get(self, "type")

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

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

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


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

@pulumi.input_type
class ServerGroupStickySessionConfigArgs:
    def __init__(__self__, *,
                 cookie: Optional[pulumi.Input[builtins.str]] = None,
                 cookie_timeout: Optional[pulumi.Input[builtins.int]] = None,
                 sticky_session_enabled: Optional[pulumi.Input[builtins.str]] = None,
                 sticky_session_type: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] cookie: 服务配置的会话保持 Cookie 名称。仅在开启会话保持功能并选择重写 Cookie 时有效。 具体规则如下：Cookie 名称长度为1~200个字符。名称只能包含 ASCII 英文字母和数字字符，不能包含半角逗号（,）、半角分号（;）或空格，也不能以美元符号（$）开头。当 tickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 server时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，该参数无效。
        :param pulumi.Input[builtins.int] cookie_timeout: 会话保持 Cookie 超时时间。仅在开启会话保持功能并选择植入 Cookie 时有效。 单位：秒。具体规则如下：超时时间的取值范围：1～86400。 默认值为：1000。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionConfig.StickySessionType 为 insert 时，此参数必填。当 StickySessionConfig.StickySessionEnabled 值为 on，且 StickySessionType 为 server 时，此参数无效。
        :param pulumi.Input[builtins.str] sticky_session_enabled: 是否开启会话保持功能。on：开启；off（默认值）：关闭。
        :param pulumi.Input[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[pulumi.Input[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")

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

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

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

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

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

    @property
    @pulumi.getter(name="stickySessionType")
    def sticky_session_type(self) -> Optional[pulumi.Input[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")

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


if not MYPY:
    class ServerGroupTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[builtins.str]]
        """
        标签的标签键。同一资源的标签键不允许重复。
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        标签的标签值。
        """
elif False:
    ServerGroupTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServerGroupTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[builtins.str]] = None,
                 value: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] key: 标签的标签键。同一资源的标签键不允许重复。
        :param pulumi.Input[builtins.str] value: 标签的标签值。
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        标签的标签键。同一资源的标签键不允许重复。
        """
        return pulumi.get(self, "key")

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

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

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


