# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'EndpointGroupEndpointConfiguration',
    'EndpointGroupPortOverrides',
    'ForwardingRuleRuleAction',
    'ForwardingRuleRuleActionForwardGroupConfig',
    'ForwardingRuleRuleActionForwardGroupConfigServerGroupTuple',
    'ForwardingRuleRuleCondition',
    'ForwardingRuleRuleConditionHostConfig',
    'ForwardingRuleRuleConditionPathConfig',
    'ListenerCertificate',
    'ListenerPortRange',
    'GetAcceleratorsAcceleratorResult',
    'GetAcceleratorsAcceleratorBasicBandwidthPackageResult',
    'GetAcceleratorsAcceleratorCrossDomainBandwidthPackageResult',
    'GetBandwidthPackagesPackageResult',
    'GetEndpointGroupsGroupResult',
    'GetEndpointGroupsGroupEndpointConfigurationResult',
    'GetEndpointGroupsGroupPortOverrideResult',
    'GetForwardingRulesForwardingRuleResult',
    'GetForwardingRulesForwardingRuleRuleActionResult',
    'GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigResult',
    'GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigServerGroupTupleResult',
    'GetForwardingRulesForwardingRuleRuleConditionResult',
    'GetForwardingRulesForwardingRuleRuleConditionHostConfigResult',
    'GetForwardingRulesForwardingRuleRuleConditionPathConfigResult',
    'GetIpSetsSetResult',
    'GetListenersListenerResult',
    'GetListenersListenerCertificateResult',
    'GetListenersListenerPortRangeResult',
]

@pulumi.output_type
class EndpointGroupEndpointConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableClientipPreservation":
            suggest = "enable_clientip_preservation"

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

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

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

    def __init__(__self__, *,
                 endpoint: str,
                 type: str,
                 weight: int,
                 enable_clientip_preservation: Optional[bool] = None):
        """
        :param str endpoint: The IP address or domain name of Endpoint N in the endpoint group.
        :param str type: The type of Endpoint N in the endpoint group. Valid values: `Domain`: a custom domain name, `Ip`: a custom IP address, `PublicIp`: an Alibaba Cloud public IP address, `ECS`: an Alibaba Cloud Elastic Compute Service (ECS) instance, `SLB`: an Alibaba Cloud Server Load Balancer (SLB) instance.
        :param int weight: The weight of Endpoint N in the endpoint group. Valid value is 0 to 255.
        :param bool enable_clientip_preservation: Indicates whether client IP addresses are reserved. Valid values: `true`: Client IP addresses are reserved, `false`: Client IP addresses are not reserved. Default value is `false`.
        """
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)
        if enable_clientip_preservation is not None:
            pulumi.set(__self__, "enable_clientip_preservation", enable_clientip_preservation)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        The IP address or domain name of Endpoint N in the endpoint group.
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of Endpoint N in the endpoint group. Valid values: `Domain`: a custom domain name, `Ip`: a custom IP address, `PublicIp`: an Alibaba Cloud public IP address, `ECS`: an Alibaba Cloud Elastic Compute Service (ECS) instance, `SLB`: an Alibaba Cloud Server Load Balancer (SLB) instance.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The weight of Endpoint N in the endpoint group. Valid value is 0 to 255.
        """
        return pulumi.get(self, "weight")

    @property
    @pulumi.getter(name="enableClientipPreservation")
    def enable_clientip_preservation(self) -> Optional[bool]:
        """
        Indicates whether client IP addresses are reserved. Valid values: `true`: Client IP addresses are reserved, `false`: Client IP addresses are not reserved. Default value is `false`.
        """
        return pulumi.get(self, "enable_clientip_preservation")


@pulumi.output_type
class EndpointGroupPortOverrides(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endpointPort":
            suggest = "endpoint_port"
        elif key == "listenerPort":
            suggest = "listener_port"

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

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

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

    def __init__(__self__, *,
                 endpoint_port: Optional[int] = None,
                 listener_port: Optional[int] = None):
        """
        :param int endpoint_port: Forwarding port.
        :param int listener_port: Listener port.
        """
        if endpoint_port is not None:
            pulumi.set(__self__, "endpoint_port", endpoint_port)
        if listener_port is not None:
            pulumi.set(__self__, "listener_port", listener_port)

    @property
    @pulumi.getter(name="endpointPort")
    def endpoint_port(self) -> Optional[int]:
        """
        Forwarding port.
        """
        return pulumi.get(self, "endpoint_port")

    @property
    @pulumi.getter(name="listenerPort")
    def listener_port(self) -> Optional[int]:
        """
        Listener port.
        """
        return pulumi.get(self, "listener_port")


@pulumi.output_type
class ForwardingRuleRuleAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "forwardGroupConfig":
            suggest = "forward_group_config"
        elif key == "ruleActionType":
            suggest = "rule_action_type"

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

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

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

    def __init__(__self__, *,
                 forward_group_config: 'outputs.ForwardingRuleRuleActionForwardGroupConfig',
                 order: int,
                 rule_action_type: str):
        """
        :param 'ForwardingRuleRuleActionForwardGroupConfigArgs' forward_group_config: Forwarding configuration.
        :param int order: Forwarding priority.
        :param str rule_action_type: Forward action type. Default: forwardgroup.
        """
        pulumi.set(__self__, "forward_group_config", forward_group_config)
        pulumi.set(__self__, "order", order)
        pulumi.set(__self__, "rule_action_type", rule_action_type)

    @property
    @pulumi.getter(name="forwardGroupConfig")
    def forward_group_config(self) -> 'outputs.ForwardingRuleRuleActionForwardGroupConfig':
        """
        Forwarding configuration.
        """
        return pulumi.get(self, "forward_group_config")

    @property
    @pulumi.getter
    def order(self) -> int:
        """
        Forwarding priority.
        """
        return pulumi.get(self, "order")

    @property
    @pulumi.getter(name="ruleActionType")
    def rule_action_type(self) -> str:
        """
        Forward action type. Default: forwardgroup.
        """
        return pulumi.get(self, "rule_action_type")


@pulumi.output_type
class ForwardingRuleRuleActionForwardGroupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serverGroupTuples":
            suggest = "server_group_tuples"

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

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

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

    def __init__(__self__, *,
                 server_group_tuples: Sequence['outputs.ForwardingRuleRuleActionForwardGroupConfigServerGroupTuple']):
        """
        :param Sequence['ForwardingRuleRuleActionForwardGroupConfigServerGroupTupleArgs'] server_group_tuples: Terminal node group configuration.
        """
        pulumi.set(__self__, "server_group_tuples", server_group_tuples)

    @property
    @pulumi.getter(name="serverGroupTuples")
    def server_group_tuples(self) -> Sequence['outputs.ForwardingRuleRuleActionForwardGroupConfigServerGroupTuple']:
        """
        Terminal node group configuration.
        """
        return pulumi.get(self, "server_group_tuples")


@pulumi.output_type
class ForwardingRuleRuleActionForwardGroupConfigServerGroupTuple(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endpointGroupId":
            suggest = "endpoint_group_id"

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

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

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

    def __init__(__self__, *,
                 endpoint_group_id: str):
        """
        :param str endpoint_group_id: Terminal node group ID.
        """
        pulumi.set(__self__, "endpoint_group_id", endpoint_group_id)

    @property
    @pulumi.getter(name="endpointGroupId")
    def endpoint_group_id(self) -> str:
        """
        Terminal node group ID.
        """
        return pulumi.get(self, "endpoint_group_id")


@pulumi.output_type
class ForwardingRuleRuleCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ruleConditionType":
            suggest = "rule_condition_type"
        elif key == "hostConfigs":
            suggest = "host_configs"
        elif key == "pathConfig":
            suggest = "path_config"

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

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

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

    def __init__(__self__, *,
                 rule_condition_type: str,
                 host_configs: Optional[Sequence['outputs.ForwardingRuleRuleConditionHostConfig']] = None,
                 path_config: Optional['outputs.ForwardingRuleRuleConditionPathConfig'] = None):
        """
        :param str rule_condition_type: Forwarding condition type. Valid value: `Host`, `Path`.
        :param Sequence['ForwardingRuleRuleConditionHostConfigArgs'] host_configs: Domain name configuration information.
        :param 'ForwardingRuleRuleConditionPathConfigArgs' path_config: Path configuration information.
        """
        pulumi.set(__self__, "rule_condition_type", rule_condition_type)
        if host_configs is not None:
            pulumi.set(__self__, "host_configs", host_configs)
        if path_config is not None:
            pulumi.set(__self__, "path_config", path_config)

    @property
    @pulumi.getter(name="ruleConditionType")
    def rule_condition_type(self) -> str:
        """
        Forwarding condition type. Valid value: `Host`, `Path`.
        """
        return pulumi.get(self, "rule_condition_type")

    @property
    @pulumi.getter(name="hostConfigs")
    def host_configs(self) -> Optional[Sequence['outputs.ForwardingRuleRuleConditionHostConfig']]:
        """
        Domain name configuration information.
        """
        return pulumi.get(self, "host_configs")

    @property
    @pulumi.getter(name="pathConfig")
    def path_config(self) -> Optional['outputs.ForwardingRuleRuleConditionPathConfig']:
        """
        Path configuration information.
        """
        return pulumi.get(self, "path_config")


@pulumi.output_type
class ForwardingRuleRuleConditionHostConfig(dict):
    def __init__(__self__, *,
                 values: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] values: The domain name is 3-128 characters long, which can contain letters, numbers, dashes (-) and width period (.), and supports the use of asterisk (*) and width question mark (?) as wildcard characters.
        """
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        """
        The domain name is 3-128 characters long, which can contain letters, numbers, dashes (-) and width period (.), and supports the use of asterisk (*) and width question mark (?) as wildcard characters.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ForwardingRuleRuleConditionPathConfig(dict):
    def __init__(__self__, *,
                 values: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] values: The domain name is 3-128 characters long, which can contain letters, numbers, dashes (-) and width period (.), and supports the use of asterisk (*) and width question mark (?) as wildcard characters.
        """
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        """
        The domain name is 3-128 characters long, which can contain letters, numbers, dashes (-) and width period (.), and supports the use of asterisk (*) and width question mark (?) as wildcard characters.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class ListenerCertificate(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None):
        """
        :param str id: The id of the certificate.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        The id of the certificate.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ListenerPortRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fromPort":
            suggest = "from_port"
        elif key == "toPort":
            suggest = "to_port"

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

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

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

    def __init__(__self__, *,
                 from_port: int,
                 to_port: int):
        """
        :param int from_port: The initial listening port used to receive requests and forward them to terminal nodes.
        :param int to_port: The end listening port used to receive requests and forward them to terminal nodes.
        """
        pulumi.set(__self__, "from_port", from_port)
        pulumi.set(__self__, "to_port", to_port)

    @property
    @pulumi.getter(name="fromPort")
    def from_port(self) -> int:
        """
        The initial listening port used to receive requests and forward them to terminal nodes.
        """
        return pulumi.get(self, "from_port")

    @property
    @pulumi.getter(name="toPort")
    def to_port(self) -> int:
        """
        The end listening port used to receive requests and forward them to terminal nodes.
        """
        return pulumi.get(self, "to_port")


@pulumi.output_type
class GetAcceleratorsAcceleratorResult(dict):
    def __init__(__self__, *,
                 accelerator_id: str,
                 accelerator_name: str,
                 basic_bandwidth_packages: Sequence['outputs.GetAcceleratorsAcceleratorBasicBandwidthPackageResult'],
                 cen_id: str,
                 cross_domain_bandwidth_packages: Sequence['outputs.GetAcceleratorsAcceleratorCrossDomainBandwidthPackageResult'],
                 ddos_id: str,
                 description: str,
                 dns_name: str,
                 expired_time: int,
                 id: str,
                 payment_type: str,
                 second_dns_name: str,
                 spec: str,
                 status: str):
        """
        :param str accelerator_id: The ID of the GA instance to query.
        :param str accelerator_name: The Name of the GA instance.
        :param Sequence['GetAcceleratorsAcceleratorBasicBandwidthPackageArgs'] basic_bandwidth_packages: Details of the basic bandwidth package bound to the global acceleration instance.
        :param str cen_id: The cloud enterprise network instance ID bound to the global acceleration instance.
        :param Sequence['GetAcceleratorsAcceleratorCrossDomainBandwidthPackageArgs'] cross_domain_bandwidth_packages: Details of the cross-domain acceleration package bound to the global acceleration instance.
        :param str ddos_id: DDoS high-defense instance ID that is unbound from the global acceleration instance.
        :param str description: Descriptive information of the global acceleration instance.
        :param str dns_name: CNAME address assigned by Global Acceleration instance.
        :param int expired_time: Time when the global acceleration instance expires.
        :param str id: The ID of the Accelerator.
        :param str payment_type: The Payment Typethe GA instance.
        :param str second_dns_name: CNAME of the Global Acceleration Linkage DDoS High Defense Instance.
        :param str spec: The instance type of the GA instance.
        :param str status: The status of the GA instance.
        """
        pulumi.set(__self__, "accelerator_id", accelerator_id)
        pulumi.set(__self__, "accelerator_name", accelerator_name)
        pulumi.set(__self__, "basic_bandwidth_packages", basic_bandwidth_packages)
        pulumi.set(__self__, "cen_id", cen_id)
        pulumi.set(__self__, "cross_domain_bandwidth_packages", cross_domain_bandwidth_packages)
        pulumi.set(__self__, "ddos_id", ddos_id)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "dns_name", dns_name)
        pulumi.set(__self__, "expired_time", expired_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "second_dns_name", second_dns_name)
        pulumi.set(__self__, "spec", spec)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="acceleratorId")
    def accelerator_id(self) -> str:
        """
        The ID of the GA instance to query.
        """
        return pulumi.get(self, "accelerator_id")

    @property
    @pulumi.getter(name="acceleratorName")
    def accelerator_name(self) -> str:
        """
        The Name of the GA instance.
        """
        return pulumi.get(self, "accelerator_name")

    @property
    @pulumi.getter(name="basicBandwidthPackages")
    def basic_bandwidth_packages(self) -> Sequence['outputs.GetAcceleratorsAcceleratorBasicBandwidthPackageResult']:
        """
        Details of the basic bandwidth package bound to the global acceleration instance.
        """
        return pulumi.get(self, "basic_bandwidth_packages")

    @property
    @pulumi.getter(name="cenId")
    def cen_id(self) -> str:
        """
        The cloud enterprise network instance ID bound to the global acceleration instance.
        """
        return pulumi.get(self, "cen_id")

    @property
    @pulumi.getter(name="crossDomainBandwidthPackages")
    def cross_domain_bandwidth_packages(self) -> Sequence['outputs.GetAcceleratorsAcceleratorCrossDomainBandwidthPackageResult']:
        """
        Details of the cross-domain acceleration package bound to the global acceleration instance.
        """
        return pulumi.get(self, "cross_domain_bandwidth_packages")

    @property
    @pulumi.getter(name="ddosId")
    def ddos_id(self) -> str:
        """
        DDoS high-defense instance ID that is unbound from the global acceleration instance.
        """
        return pulumi.get(self, "ddos_id")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Descriptive information of the global acceleration instance.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="dnsName")
    def dns_name(self) -> str:
        """
        CNAME address assigned by Global Acceleration instance.
        """
        return pulumi.get(self, "dns_name")

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> int:
        """
        Time when the global acceleration instance expires.
        """
        return pulumi.get(self, "expired_time")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Accelerator.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="paymentType")
    def payment_type(self) -> str:
        """
        The Payment Typethe GA instance.
        """
        return pulumi.get(self, "payment_type")

    @property
    @pulumi.getter(name="secondDnsName")
    def second_dns_name(self) -> str:
        """
        CNAME of the Global Acceleration Linkage DDoS High Defense Instance.
        """
        return pulumi.get(self, "second_dns_name")

    @property
    @pulumi.getter
    def spec(self) -> str:
        """
        The instance type of the GA instance.
        """
        return pulumi.get(self, "spec")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the GA instance.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetAcceleratorsAcceleratorBasicBandwidthPackageResult(dict):
    def __init__(__self__, *,
                 bandwidth: int,
                 bandwidth_type: str,
                 instance_id: str):
        """
        :param int bandwidth: Bandwidth value of cross-domain acceleration package.
        :param str bandwidth_type: The bandwidth type of the basic bandwidth package.
        :param str instance_id: Instance ID of the cross-domain acceleration package.
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "bandwidth_type", bandwidth_type)
        pulumi.set(__self__, "instance_id", instance_id)

    @property
    @pulumi.getter
    def bandwidth(self) -> int:
        """
        Bandwidth value of cross-domain acceleration package.
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="bandwidthType")
    def bandwidth_type(self) -> str:
        """
        The bandwidth type of the basic bandwidth package.
        """
        return pulumi.get(self, "bandwidth_type")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        Instance ID of the cross-domain acceleration package.
        """
        return pulumi.get(self, "instance_id")


@pulumi.output_type
class GetAcceleratorsAcceleratorCrossDomainBandwidthPackageResult(dict):
    def __init__(__self__, *,
                 bandwidth: int,
                 instance_id: str):
        """
        :param int bandwidth: Bandwidth value of cross-domain acceleration package.
        :param str instance_id: Instance ID of the cross-domain acceleration package.
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "instance_id", instance_id)

    @property
    @pulumi.getter
    def bandwidth(self) -> int:
        """
        Bandwidth value of cross-domain acceleration package.
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        Instance ID of the cross-domain acceleration package.
        """
        return pulumi.get(self, "instance_id")


@pulumi.output_type
class GetBandwidthPackagesPackageResult(dict):
    def __init__(__self__, *,
                 bandwidth: int,
                 bandwidth_package_id: str,
                 bandwidth_package_name: str,
                 bandwidth_type: str,
                 cbn_geographic_region_ida: str,
                 cbn_geographic_region_idb: str,
                 description: str,
                 expired_time: str,
                 id: str,
                 payment_type: str,
                 status: str,
                 type: str):
        """
        :param int bandwidth: The bandwidth value of bandwidth packet.
        :param str bandwidth_package_id: The Resource ID of the bandwidth.
        :param str bandwidth_package_name: The name of the bandwidth packet.
        :param str bandwidth_type: The bandwidth type of the bandwidth.
        :param str cbn_geographic_region_ida: Interworking area A of cross domain acceleration package. Only international stations support returning this parameter.
        :param str cbn_geographic_region_idb: Interworking area B of cross domain acceleration package. Only international stations support returning this parameter.
        :param str description: The description of bandwidth package.
        :param str expired_time: Bandwidth package expiration time.
        :param str id: The ID of the Bandwidth Package.
        :param str payment_type: The payment type of the bandwidth.
        :param str status: The status of the bandwidth plan.
        :param str type: The type of the bandwidth packet. China station only supports return to basic.
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "bandwidth_package_id", bandwidth_package_id)
        pulumi.set(__self__, "bandwidth_package_name", bandwidth_package_name)
        pulumi.set(__self__, "bandwidth_type", bandwidth_type)
        pulumi.set(__self__, "cbn_geographic_region_ida", cbn_geographic_region_ida)
        pulumi.set(__self__, "cbn_geographic_region_idb", cbn_geographic_region_idb)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "expired_time", expired_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def bandwidth(self) -> int:
        """
        The bandwidth value of bandwidth packet.
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter(name="bandwidthPackageId")
    def bandwidth_package_id(self) -> str:
        """
        The Resource ID of the bandwidth.
        """
        return pulumi.get(self, "bandwidth_package_id")

    @property
    @pulumi.getter(name="bandwidthPackageName")
    def bandwidth_package_name(self) -> str:
        """
        The name of the bandwidth packet.
        """
        return pulumi.get(self, "bandwidth_package_name")

    @property
    @pulumi.getter(name="bandwidthType")
    def bandwidth_type(self) -> str:
        """
        The bandwidth type of the bandwidth.
        """
        return pulumi.get(self, "bandwidth_type")

    @property
    @pulumi.getter(name="cbnGeographicRegionIda")
    def cbn_geographic_region_ida(self) -> str:
        """
        Interworking area A of cross domain acceleration package. Only international stations support returning this parameter.
        """
        return pulumi.get(self, "cbn_geographic_region_ida")

    @property
    @pulumi.getter(name="cbnGeographicRegionIdb")
    def cbn_geographic_region_idb(self) -> str:
        """
        Interworking area B of cross domain acceleration package. Only international stations support returning this parameter.
        """
        return pulumi.get(self, "cbn_geographic_region_idb")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description of bandwidth package.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> str:
        """
        Bandwidth package expiration time.
        """
        return pulumi.get(self, "expired_time")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Bandwidth Package.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="paymentType")
    def payment_type(self) -> str:
        """
        The payment type of the bandwidth.
        """
        return pulumi.get(self, "payment_type")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the bandwidth plan.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the bandwidth packet. China station only supports return to basic.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetEndpointGroupsGroupResult(dict):
    def __init__(__self__, *,
                 description: str,
                 endpoint_configurations: Sequence['outputs.GetEndpointGroupsGroupEndpointConfigurationResult'],
                 endpoint_group_id: str,
                 endpoint_group_region: str,
                 health_check_interval_seconds: int,
                 health_check_path: str,
                 health_check_port: int,
                 health_check_protocol: str,
                 id: str,
                 listener_id: str,
                 name: str,
                 port_overrides: Sequence['outputs.GetEndpointGroupsGroupPortOverrideResult'],
                 status: str,
                 threshold_count: int,
                 traffic_percentage: int):
        """
        :param str description: The description of the endpoint group.
        :param Sequence['GetEndpointGroupsGroupEndpointConfigurationArgs'] endpoint_configurations: The endpointConfigurations of the endpoint group.
        :param str endpoint_group_id: The endpoint_group_id of the Endpoint Group.
        :param str endpoint_group_region: The ID of the region where the endpoint group is deployed.
        :param int health_check_interval_seconds: The interval between two consecutive health checks. Unit: seconds.
        :param str health_check_path: The path specified as the destination of the targets for health checks.
        :param int health_check_port: The port that is used for health checks.
        :param str health_check_protocol: The protocol that is used to connect to the targets for health checks.
        :param str id: The ID of the Endpoint Group.
        :param str listener_id: The ID of the listener that is associated with the endpoint group.
        :param str name: The name of the endpoint group.
        :param Sequence['GetEndpointGroupsGroupPortOverrideArgs'] port_overrides: Mapping between listening port and forwarding port of boarding point.
        :param str status: The status of the endpoint group.
        :param int threshold_count: The number of consecutive failed heath checks that must occur before the endpoint is deemed unhealthy.
        :param int traffic_percentage: The weight of the endpoint group when the corresponding listener is associated with multiple endpoint groups.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "endpoint_configurations", endpoint_configurations)
        pulumi.set(__self__, "endpoint_group_id", endpoint_group_id)
        pulumi.set(__self__, "endpoint_group_region", endpoint_group_region)
        pulumi.set(__self__, "health_check_interval_seconds", health_check_interval_seconds)
        pulumi.set(__self__, "health_check_path", health_check_path)
        pulumi.set(__self__, "health_check_port", health_check_port)
        pulumi.set(__self__, "health_check_protocol", health_check_protocol)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "listener_id", listener_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port_overrides", port_overrides)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "threshold_count", threshold_count)
        pulumi.set(__self__, "traffic_percentage", traffic_percentage)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description of the endpoint group.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="endpointConfigurations")
    def endpoint_configurations(self) -> Sequence['outputs.GetEndpointGroupsGroupEndpointConfigurationResult']:
        """
        The endpointConfigurations of the endpoint group.
        """
        return pulumi.get(self, "endpoint_configurations")

    @property
    @pulumi.getter(name="endpointGroupId")
    def endpoint_group_id(self) -> str:
        """
        The endpoint_group_id of the Endpoint Group.
        """
        return pulumi.get(self, "endpoint_group_id")

    @property
    @pulumi.getter(name="endpointGroupRegion")
    def endpoint_group_region(self) -> str:
        """
        The ID of the region where the endpoint group is deployed.
        """
        return pulumi.get(self, "endpoint_group_region")

    @property
    @pulumi.getter(name="healthCheckIntervalSeconds")
    def health_check_interval_seconds(self) -> int:
        """
        The interval between two consecutive health checks. Unit: seconds.
        """
        return pulumi.get(self, "health_check_interval_seconds")

    @property
    @pulumi.getter(name="healthCheckPath")
    def health_check_path(self) -> str:
        """
        The path specified as the destination of the targets for health checks.
        """
        return pulumi.get(self, "health_check_path")

    @property
    @pulumi.getter(name="healthCheckPort")
    def health_check_port(self) -> int:
        """
        The port that is used for health checks.
        """
        return pulumi.get(self, "health_check_port")

    @property
    @pulumi.getter(name="healthCheckProtocol")
    def health_check_protocol(self) -> str:
        """
        The protocol that is used to connect to the targets for health checks.
        """
        return pulumi.get(self, "health_check_protocol")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Endpoint Group.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="listenerId")
    def listener_id(self) -> str:
        """
        The ID of the listener that is associated with the endpoint group.
        """
        return pulumi.get(self, "listener_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the endpoint group.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="portOverrides")
    def port_overrides(self) -> Sequence['outputs.GetEndpointGroupsGroupPortOverrideResult']:
        """
        Mapping between listening port and forwarding port of boarding point.
        """
        return pulumi.get(self, "port_overrides")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the endpoint group.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="thresholdCount")
    def threshold_count(self) -> int:
        """
        The number of consecutive failed heath checks that must occur before the endpoint is deemed unhealthy.
        """
        return pulumi.get(self, "threshold_count")

    @property
    @pulumi.getter(name="trafficPercentage")
    def traffic_percentage(self) -> int:
        """
        The weight of the endpoint group when the corresponding listener is associated with multiple endpoint groups.
        """
        return pulumi.get(self, "traffic_percentage")


@pulumi.output_type
class GetEndpointGroupsGroupEndpointConfigurationResult(dict):
    def __init__(__self__, *,
                 enable_clientip_preservation: bool,
                 endpoint: str,
                 probe_port: int,
                 probe_protocol: str,
                 type: str,
                 weight: int):
        """
        :param bool enable_clientip_preservation: Indicates whether client IP addresses are reserved.
        :param str endpoint: The IP address or domain name of Endpoint N in the endpoint group.
        :param int probe_port: Probe Port.
        :param str probe_protocol: Probe Protocol.
        :param str type: The type of Endpoint N in the endpoint group.
        :param int weight: The weight of Endpoint N in the endpoint group.
        """
        pulumi.set(__self__, "enable_clientip_preservation", enable_clientip_preservation)
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "probe_port", probe_port)
        pulumi.set(__self__, "probe_protocol", probe_protocol)
        pulumi.set(__self__, "type", type)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="enableClientipPreservation")
    def enable_clientip_preservation(self) -> bool:
        """
        Indicates whether client IP addresses are reserved.
        """
        return pulumi.get(self, "enable_clientip_preservation")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        The IP address or domain name of Endpoint N in the endpoint group.
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="probePort")
    def probe_port(self) -> int:
        """
        Probe Port.
        """
        return pulumi.get(self, "probe_port")

    @property
    @pulumi.getter(name="probeProtocol")
    def probe_protocol(self) -> str:
        """
        Probe Protocol.
        """
        return pulumi.get(self, "probe_protocol")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of Endpoint N in the endpoint group.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The weight of Endpoint N in the endpoint group.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetEndpointGroupsGroupPortOverrideResult(dict):
    def __init__(__self__, *,
                 endpoint_port: int,
                 listener_port: int):
        """
        :param int endpoint_port: Forwarding port.
        :param int listener_port: Listener port.
        """
        pulumi.set(__self__, "endpoint_port", endpoint_port)
        pulumi.set(__self__, "listener_port", listener_port)

    @property
    @pulumi.getter(name="endpointPort")
    def endpoint_port(self) -> int:
        """
        Forwarding port.
        """
        return pulumi.get(self, "endpoint_port")

    @property
    @pulumi.getter(name="listenerPort")
    def listener_port(self) -> int:
        """
        Listener port.
        """
        return pulumi.get(self, "listener_port")


@pulumi.output_type
class GetForwardingRulesForwardingRuleResult(dict):
    def __init__(__self__, *,
                 forwarding_rule_id: str,
                 forwarding_rule_name: str,
                 forwarding_rule_status: str,
                 id: str,
                 listener_id: str,
                 priority: int,
                 rule_actions: Sequence['outputs.GetForwardingRulesForwardingRuleRuleActionResult'],
                 rule_conditions: Sequence['outputs.GetForwardingRulesForwardingRuleRuleConditionResult']):
        """
        :param str forwarding_rule_id: Forwarding Policy ID.
        :param str forwarding_rule_name: Forwarding policy name. The length of the name is 2-128 English or Chinese characters.
        :param str forwarding_rule_status: Forwarding Policy Status.
        :param str listener_id: The ID of the listener.
        :param int priority: Forwarding policy priority.
        :param Sequence['GetForwardingRulesForwardingRuleRuleActionArgs'] rule_actions: The IP protocol used by the GA instance.
               `order` - Forwarding priority.
               `rule_action_type` - Forward action type.
               `forward_group_config` - Forwarding configuration.
               `server_group_tuples` - Terminal node group configuration.
               `endpoint_group_id` - Terminal node group ID.
        :param Sequence['GetForwardingRulesForwardingRuleRuleConditionArgs'] rule_conditions: Forward action.
               `rule_condition_type` - Forwarding condition type.
               `path_config` - Path configuration information.
               `values` - The length of the path is 1-128 characters.
               `host_config` - Domain name configuration information.
               `values` - The domain name is 3-128 characters long.
        """
        pulumi.set(__self__, "forwarding_rule_id", forwarding_rule_id)
        pulumi.set(__self__, "forwarding_rule_name", forwarding_rule_name)
        pulumi.set(__self__, "forwarding_rule_status", forwarding_rule_status)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "listener_id", listener_id)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "rule_actions", rule_actions)
        pulumi.set(__self__, "rule_conditions", rule_conditions)

    @property
    @pulumi.getter(name="forwardingRuleId")
    def forwarding_rule_id(self) -> str:
        """
        Forwarding Policy ID.
        """
        return pulumi.get(self, "forwarding_rule_id")

    @property
    @pulumi.getter(name="forwardingRuleName")
    def forwarding_rule_name(self) -> str:
        """
        Forwarding policy name. The length of the name is 2-128 English or Chinese characters.
        """
        return pulumi.get(self, "forwarding_rule_name")

    @property
    @pulumi.getter(name="forwardingRuleStatus")
    def forwarding_rule_status(self) -> str:
        """
        Forwarding Policy Status.
        """
        return pulumi.get(self, "forwarding_rule_status")

    @property
    @pulumi.getter
    def id(self) -> str:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="listenerId")
    def listener_id(self) -> str:
        """
        The ID of the listener.
        """
        return pulumi.get(self, "listener_id")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        Forwarding policy priority.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter(name="ruleActions")
    def rule_actions(self) -> Sequence['outputs.GetForwardingRulesForwardingRuleRuleActionResult']:
        """
        The IP protocol used by the GA instance.
        `order` - Forwarding priority.
        `rule_action_type` - Forward action type.
        `forward_group_config` - Forwarding configuration.
        `server_group_tuples` - Terminal node group configuration.
        `endpoint_group_id` - Terminal node group ID.
        """
        return pulumi.get(self, "rule_actions")

    @property
    @pulumi.getter(name="ruleConditions")
    def rule_conditions(self) -> Sequence['outputs.GetForwardingRulesForwardingRuleRuleConditionResult']:
        """
        Forward action.
        `rule_condition_type` - Forwarding condition type.
        `path_config` - Path configuration information.
        `values` - The length of the path is 1-128 characters.
        `host_config` - Domain name configuration information.
        `values` - The domain name is 3-128 characters long.
        """
        return pulumi.get(self, "rule_conditions")


@pulumi.output_type
class GetForwardingRulesForwardingRuleRuleActionResult(dict):
    def __init__(__self__, *,
                 forward_group_configs: Sequence['outputs.GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigResult'],
                 order: int,
                 rule_action_type: str):
        pulumi.set(__self__, "forward_group_configs", forward_group_configs)
        pulumi.set(__self__, "order", order)
        pulumi.set(__self__, "rule_action_type", rule_action_type)

    @property
    @pulumi.getter(name="forwardGroupConfigs")
    def forward_group_configs(self) -> Sequence['outputs.GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigResult']:
        return pulumi.get(self, "forward_group_configs")

    @property
    @pulumi.getter
    def order(self) -> int:
        return pulumi.get(self, "order")

    @property
    @pulumi.getter(name="ruleActionType")
    def rule_action_type(self) -> str:
        return pulumi.get(self, "rule_action_type")


@pulumi.output_type
class GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigResult(dict):
    def __init__(__self__, *,
                 server_group_tuples: Sequence['outputs.GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigServerGroupTupleResult']):
        pulumi.set(__self__, "server_group_tuples", server_group_tuples)

    @property
    @pulumi.getter(name="serverGroupTuples")
    def server_group_tuples(self) -> Sequence['outputs.GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigServerGroupTupleResult']:
        return pulumi.get(self, "server_group_tuples")


@pulumi.output_type
class GetForwardingRulesForwardingRuleRuleActionForwardGroupConfigServerGroupTupleResult(dict):
    def __init__(__self__, *,
                 endpoint_group_id: str):
        pulumi.set(__self__, "endpoint_group_id", endpoint_group_id)

    @property
    @pulumi.getter(name="endpointGroupId")
    def endpoint_group_id(self) -> str:
        return pulumi.get(self, "endpoint_group_id")


@pulumi.output_type
class GetForwardingRulesForwardingRuleRuleConditionResult(dict):
    def __init__(__self__, *,
                 host_configs: Sequence['outputs.GetForwardingRulesForwardingRuleRuleConditionHostConfigResult'],
                 path_configs: Sequence['outputs.GetForwardingRulesForwardingRuleRuleConditionPathConfigResult'],
                 rule_condition_type: str):
        pulumi.set(__self__, "host_configs", host_configs)
        pulumi.set(__self__, "path_configs", path_configs)
        pulumi.set(__self__, "rule_condition_type", rule_condition_type)

    @property
    @pulumi.getter(name="hostConfigs")
    def host_configs(self) -> Sequence['outputs.GetForwardingRulesForwardingRuleRuleConditionHostConfigResult']:
        return pulumi.get(self, "host_configs")

    @property
    @pulumi.getter(name="pathConfigs")
    def path_configs(self) -> Sequence['outputs.GetForwardingRulesForwardingRuleRuleConditionPathConfigResult']:
        return pulumi.get(self, "path_configs")

    @property
    @pulumi.getter(name="ruleConditionType")
    def rule_condition_type(self) -> str:
        return pulumi.get(self, "rule_condition_type")


@pulumi.output_type
class GetForwardingRulesForwardingRuleRuleConditionHostConfigResult(dict):
    def __init__(__self__, *,
                 values: Sequence[str]):
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        return pulumi.get(self, "values")


@pulumi.output_type
class GetForwardingRulesForwardingRuleRuleConditionPathConfigResult(dict):
    def __init__(__self__, *,
                 values: Sequence[str]):
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        return pulumi.get(self, "values")


@pulumi.output_type
class GetIpSetsSetResult(dict):
    def __init__(__self__, *,
                 accelerate_region_id: str,
                 bandwidth: int,
                 id: str,
                 ip_address_lists: Sequence[str],
                 ip_set_id: str,
                 ip_version: str,
                 status: str):
        """
        :param str accelerate_region_id: The ID of an acceleration region.
        :param int bandwidth: The bandwidth allocated to the acceleration region.
        :param str id: The ID of the Ip Set.
        :param Sequence[str] ip_address_lists: The list of accelerated IP addresses in the acceleration region.
        :param str ip_set_id: Accelerated area ID.
        :param str ip_version: The IP protocol used by the GA instance.
        :param str status: The status of the acceleration region.
        """
        pulumi.set(__self__, "accelerate_region_id", accelerate_region_id)
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ip_address_lists", ip_address_lists)
        pulumi.set(__self__, "ip_set_id", ip_set_id)
        pulumi.set(__self__, "ip_version", ip_version)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="accelerateRegionId")
    def accelerate_region_id(self) -> str:
        """
        The ID of an acceleration region.
        """
        return pulumi.get(self, "accelerate_region_id")

    @property
    @pulumi.getter
    def bandwidth(self) -> int:
        """
        The bandwidth allocated to the acceleration region.
        """
        return pulumi.get(self, "bandwidth")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Ip Set.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="ipAddressLists")
    def ip_address_lists(self) -> Sequence[str]:
        """
        The list of accelerated IP addresses in the acceleration region.
        """
        return pulumi.get(self, "ip_address_lists")

    @property
    @pulumi.getter(name="ipSetId")
    def ip_set_id(self) -> str:
        """
        Accelerated area ID.
        """
        return pulumi.get(self, "ip_set_id")

    @property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> str:
        """
        The IP protocol used by the GA instance.
        """
        return pulumi.get(self, "ip_version")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the acceleration region.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetListenersListenerResult(dict):
    def __init__(__self__, *,
                 certificates: Sequence['outputs.GetListenersListenerCertificateResult'],
                 client_affinity: str,
                 description: str,
                 id: str,
                 listener_id: str,
                 name: str,
                 port_ranges: Sequence['outputs.GetListenersListenerPortRangeResult'],
                 protocol: str,
                 status: str):
        """
        :param Sequence['GetListenersListenerCertificateArgs'] certificates: The certificates of the listener.
        :param str client_affinity: The clientAffinity of the listener.
        :param str description: The description of the listener.
        :param str id: The ID of the Listener.
        :param str listener_id: The listenerId of the listener.
        :param str name: The name of the listener. The length of the name is 2-128 characters. It starts with uppercase and lowercase letters or Chinese characters. It can contain numbers and underscores and dashes.
        :param Sequence['GetListenersListenerPortRangeArgs'] port_ranges: The portRanges of the listener.
        :param str protocol: Type of network transport protocol monitored.
        :param str status: The status of the listener.
        """
        pulumi.set(__self__, "certificates", certificates)
        pulumi.set(__self__, "client_affinity", client_affinity)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "listener_id", listener_id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port_ranges", port_ranges)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def certificates(self) -> Sequence['outputs.GetListenersListenerCertificateResult']:
        """
        The certificates of the listener.
        """
        return pulumi.get(self, "certificates")

    @property
    @pulumi.getter(name="clientAffinity")
    def client_affinity(self) -> str:
        """
        The clientAffinity of the listener.
        """
        return pulumi.get(self, "client_affinity")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        The description of the listener.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Listener.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="listenerId")
    def listener_id(self) -> str:
        """
        The listenerId of the listener.
        """
        return pulumi.get(self, "listener_id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the listener. The length of the name is 2-128 characters. It starts with uppercase and lowercase letters or Chinese characters. It can contain numbers and underscores and dashes.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="portRanges")
    def port_ranges(self) -> Sequence['outputs.GetListenersListenerPortRangeResult']:
        """
        The portRanges of the listener.
        """
        return pulumi.get(self, "port_ranges")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        Type of network transport protocol monitored.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the listener.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetListenersListenerCertificateResult(dict):
    def __init__(__self__, *,
                 id: str,
                 type: str):
        """
        :param str id: The ID of the Listener.
        :param str type: The type of the certificate.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Listener.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of the certificate.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetListenersListenerPortRangeResult(dict):
    def __init__(__self__, *,
                 from_port: int,
                 to_port: int):
        """
        :param int from_port: The initial listening port used to receive requests and forward them to terminal nodes.
        :param int to_port: The end listening port used to receive requests and forward them to terminal nodes.
        """
        pulumi.set(__self__, "from_port", from_port)
        pulumi.set(__self__, "to_port", to_port)

    @property
    @pulumi.getter(name="fromPort")
    def from_port(self) -> int:
        """
        The initial listening port used to receive requests and forward them to terminal nodes.
        """
        return pulumi.get(self, "from_port")

    @property
    @pulumi.getter(name="toPort")
    def to_port(self) -> int:
        """
        The end listening port used to receive requests and forward them to terminal nodes.
        """
        return pulumi.get(self, "to_port")


