# 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__ = [
    'DhcpOptionsSetAssociateVpc',
    'NetworkAclAttachmentResource',
    'NetworkAclEgressAclEntry',
    'NetworkAclEntriesEgress',
    'NetworkAclEntriesIngress',
    'NetworkAclIngressAclEntry',
    'NetworkAclResource',
    'GetCommonBandwidthPackagesPackageResult',
    'GetCommonBandwidthPackagesPackagePublicIpAddressResult',
    'GetDhcpOptionsSetsSetResult',
    'GetDhcpOptionsSetsSetAssociateVpcResult',
    'GetEnhancedNatAvailableZonesZoneResult',
    'GetForwardEntriesEntryResult',
    'GetHavipsHavipResult',
    'GetIpv6AddressesAddressResult',
    'GetIpv6EgressRulesRuleResult',
    'GetIpv6GatewaysGatewayResult',
    'GetIpv6InternetBandwidthsBandwidthResult',
    'GetNatGatewaysGatewayResult',
    'GetNatIpCidrsCidrResult',
    'GetNatIpsIpResult',
    'GetNetworkAclsAclResult',
    'GetNetworkAclsAclEgressAclEntryResult',
    'GetNetworkAclsAclIngressAclEntryResult',
    'GetNetworkAclsAclResourceResult',
    'GetNetworksVpcResult',
    'GetRouteEntriesEntryResult',
    'GetRouteTablesTableResult',
    'GetRouterInterfacesInterfaceResult',
    'GetSnatEntriesEntryResult',
    'GetSslVpnClientCertsCertResult',
    'GetSslVpnServersServerResult',
    'GetSwitchesVswitchResult',
    'GetTrafficMirrorFilterEgressRulesRuleResult',
    'GetTrafficMirrorFilterIngressRulesRuleResult',
    'GetTrafficMirrorFiltersFilterResult',
    'GetTrafficMirrorSessionsSessionResult',
    'GetVpcFlowLogsLogResult',
]

@pulumi.output_type
class DhcpOptionsSetAssociateVpc(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "associateStatus":
            suggest = "associate_status"
        elif key == "vpcId":
            suggest = "vpc_id"

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

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

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

    def __init__(__self__, *,
                 associate_status: Optional[str] = None,
                 vpc_id: Optional[str] = None):
        """
        :param str associate_status: The status of the VPC network that is associated with the DHCP options set. Valid values:`InUse` or `Pending`. `InUse`: The VPC network is in use. `Pending`: The VPC network is being configured.
        :param str vpc_id: The ID of the VPC network that is associated with the DHCP options set.
        """
        if associate_status is not None:
            pulumi.set(__self__, "associate_status", associate_status)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="associateStatus")
    def associate_status(self) -> Optional[str]:
        """
        The status of the VPC network that is associated with the DHCP options set. Valid values:`InUse` or `Pending`. `InUse`: The VPC network is in use. `Pending`: The VPC network is being configured.
        """
        return pulumi.get(self, "associate_status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[str]:
        """
        The ID of the VPC network that is associated with the DHCP options set.
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class NetworkAclAttachmentResource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceId":
            suggest = "resource_id"
        elif key == "resourceType":
            suggest = "resource_type"

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

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

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

    def __init__(__self__, *,
                 resource_id: str,
                 resource_type: str):
        """
        :param str resource_id: The resource id that the network acl will associate with.
        :param str resource_type: The resource id that the network acl will associate with. Only support `VSwitch` now.
        """
        pulumi.set(__self__, "resource_id", resource_id)
        pulumi.set(__self__, "resource_type", resource_type)

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> str:
        """
        The resource id that the network acl will associate with.
        """
        return pulumi.get(self, "resource_id")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        The resource id that the network acl will associate with. Only support `VSwitch` now.
        """
        return pulumi.get(self, "resource_type")


@pulumi.output_type
class NetworkAclEgressAclEntry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationCidrIp":
            suggest = "destination_cidr_ip"
        elif key == "networkAclEntryName":
            suggest = "network_acl_entry_name"

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

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

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

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 destination_cidr_ip: Optional[str] = None,
                 network_acl_entry_name: Optional[str] = None,
                 policy: Optional[str] = None,
                 port: Optional[str] = None,
                 protocol: Optional[str] = None):
        """
        :param str description: The description of egress entries.
        :param str destination_cidr_ip: The destination cidr ip of egress entries.
        :param str network_acl_entry_name: The entry name of egress entries.
        :param str policy: The policy of egress entries. Valid values `accept` and `drop`.
        :param str port: The port of egress entries.
        :param str protocol: The protocol of egress entries. Valid values `icmp`,`gre`,`tcp`,`udp`, and `all`.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if destination_cidr_ip is not None:
            pulumi.set(__self__, "destination_cidr_ip", destination_cidr_ip)
        if network_acl_entry_name is not None:
            pulumi.set(__self__, "network_acl_entry_name", network_acl_entry_name)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The description of egress entries.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="destinationCidrIp")
    def destination_cidr_ip(self) -> Optional[str]:
        """
        The destination cidr ip of egress entries.
        """
        return pulumi.get(self, "destination_cidr_ip")

    @property
    @pulumi.getter(name="networkAclEntryName")
    def network_acl_entry_name(self) -> Optional[str]:
        """
        The entry name of egress entries.
        """
        return pulumi.get(self, "network_acl_entry_name")

    @property
    @pulumi.getter
    def policy(self) -> Optional[str]:
        """
        The policy of egress entries. Valid values `accept` and `drop`.
        """
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        """
        The port of egress entries.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The protocol of egress entries. Valid values `icmp`,`gre`,`tcp`,`udp`, and `all`.
        """
        return pulumi.get(self, "protocol")


@pulumi.output_type
class NetworkAclEntriesEgress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "destinationCidrIp":
            suggest = "destination_cidr_ip"
        elif key == "entryType":
            suggest = "entry_type"

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

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

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

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 destination_cidr_ip: Optional[str] = None,
                 entry_type: Optional[str] = None,
                 name: Optional[str] = None,
                 policy: Optional[str] = None,
                 port: Optional[str] = None,
                 protocol: Optional[str] = None):
        """
        :param str description: The description of the egress entry.
        :param str destination_cidr_ip: The destination ip of the egress entry.
        :param str entry_type: The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
        :param str name: The name of the egress entry.
        :param str policy: The policy of the egress entry. It must be `accept` or `drop`.
        :param str port: The port of the egress entry.
        :param str protocol: The protocol of the egress entry.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if destination_cidr_ip is not None:
            pulumi.set(__self__, "destination_cidr_ip", destination_cidr_ip)
        if entry_type is not None:
            pulumi.set(__self__, "entry_type", entry_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)

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

    @property
    @pulumi.getter(name="destinationCidrIp")
    def destination_cidr_ip(self) -> Optional[str]:
        """
        The destination ip of the egress entry.
        """
        return pulumi.get(self, "destination_cidr_ip")

    @property
    @pulumi.getter(name="entryType")
    def entry_type(self) -> Optional[str]:
        """
        The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
        """
        return pulumi.get(self, "entry_type")

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

    @property
    @pulumi.getter
    def policy(self) -> Optional[str]:
        """
        The policy of the egress entry. It must be `accept` or `drop`.
        """
        return pulumi.get(self, "policy")

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

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


@pulumi.output_type
class NetworkAclEntriesIngress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "entryType":
            suggest = "entry_type"
        elif key == "sourceCidrIp":
            suggest = "source_cidr_ip"

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

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

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

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 entry_type: Optional[str] = None,
                 name: Optional[str] = None,
                 policy: Optional[str] = None,
                 port: Optional[str] = None,
                 protocol: Optional[str] = None,
                 source_cidr_ip: Optional[str] = None):
        """
        :param str description: The description of the egress entry.
        :param str entry_type: The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
        :param str name: The name of the egress entry.
        :param str policy: The policy of the egress entry. It must be `accept` or `drop`.
        :param str port: The port of the egress entry.
        :param str protocol: The protocol of the egress entry.
        :param str source_cidr_ip: The source ip of the ingress entry.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if entry_type is not None:
            pulumi.set(__self__, "entry_type", entry_type)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if source_cidr_ip is not None:
            pulumi.set(__self__, "source_cidr_ip", source_cidr_ip)

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

    @property
    @pulumi.getter(name="entryType")
    def entry_type(self) -> Optional[str]:
        """
        The entry type of the egress entry. It must be `custom` or `system`. Default value is `custom`.
        """
        return pulumi.get(self, "entry_type")

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

    @property
    @pulumi.getter
    def policy(self) -> Optional[str]:
        """
        The policy of the egress entry. It must be `accept` or `drop`.
        """
        return pulumi.get(self, "policy")

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

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

    @property
    @pulumi.getter(name="sourceCidrIp")
    def source_cidr_ip(self) -> Optional[str]:
        """
        The source ip of the ingress entry.
        """
        return pulumi.get(self, "source_cidr_ip")


@pulumi.output_type
class NetworkAclIngressAclEntry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkAclEntryName":
            suggest = "network_acl_entry_name"
        elif key == "sourceCidrIp":
            suggest = "source_cidr_ip"

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

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

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

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 network_acl_entry_name: Optional[str] = None,
                 policy: Optional[str] = None,
                 port: Optional[str] = None,
                 protocol: Optional[str] = None,
                 source_cidr_ip: Optional[str] = None):
        """
        :param str description: The description of egress entries.
        :param str network_acl_entry_name: The entry name of egress entries.
        :param str policy: The policy of egress entries. Valid values `accept` and `drop`.
        :param str port: The port of egress entries.
        :param str protocol: The protocol of egress entries. Valid values `icmp`,`gre`,`tcp`,`udp`, and `all`.
        :param str source_cidr_ip: The source cidr ip of ingress entries.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if network_acl_entry_name is not None:
            pulumi.set(__self__, "network_acl_entry_name", network_acl_entry_name)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if protocol is not None:
            pulumi.set(__self__, "protocol", protocol)
        if source_cidr_ip is not None:
            pulumi.set(__self__, "source_cidr_ip", source_cidr_ip)

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The description of egress entries.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="networkAclEntryName")
    def network_acl_entry_name(self) -> Optional[str]:
        """
        The entry name of egress entries.
        """
        return pulumi.get(self, "network_acl_entry_name")

    @property
    @pulumi.getter
    def policy(self) -> Optional[str]:
        """
        The policy of egress entries. Valid values `accept` and `drop`.
        """
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        """
        The port of egress entries.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> Optional[str]:
        """
        The protocol of egress entries. Valid values `icmp`,`gre`,`tcp`,`udp`, and `all`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="sourceCidrIp")
    def source_cidr_ip(self) -> Optional[str]:
        """
        The source cidr ip of ingress entries.
        """
        return pulumi.get(self, "source_cidr_ip")


@pulumi.output_type
class NetworkAclResource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceId":
            suggest = "resource_id"
        elif key == "resourceType":
            suggest = "resource_type"

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

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

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

    def __init__(__self__, *,
                 resource_id: Optional[str] = None,
                 resource_type: Optional[str] = None):
        """
        :param str resource_id: The ID of the associated resource.
        :param str resource_type: The type of the associated resource. Valid values `VSwitch`.
        """
        if resource_id is not None:
            pulumi.set(__self__, "resource_id", resource_id)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> Optional[str]:
        """
        The ID of the associated resource.
        """
        return pulumi.get(self, "resource_id")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> Optional[str]:
        """
        The type of the associated resource. Valid values `VSwitch`.
        """
        return pulumi.get(self, "resource_type")


@pulumi.output_type
class GetCommonBandwidthPackagesPackageResult(dict):
    def __init__(__self__, *,
                 bandwidth: str,
                 bandwidth_package_id: str,
                 bandwidth_package_name: str,
                 business_status: str,
                 deletion_protection: bool,
                 description: str,
                 expired_time: str,
                 has_reservation_data: bool,
                 id: str,
                 internet_charge_type: str,
                 isp: str,
                 name: str,
                 payment_type: str,
                 public_ip_addresses: Sequence['outputs.GetCommonBandwidthPackagesPackagePublicIpAddressResult'],
                 ratio: int,
                 reservation_active_time: str,
                 reservation_bandwidth: str,
                 reservation_internet_charge_type: str,
                 reservation_order_type: str,
                 resource_group_id: str,
                 service_managed: int,
                 status: str):
        """
        :param str bandwidth: The peak bandwidth of the Internet Shared Bandwidth instance.
        :param str bandwidth_package_id: The resource ID of bandwidth package.
        :param str bandwidth_package_name: The name of bandwidth package.
        :param str business_status: The business status of the Common Bandwidth Package instance.
        :param bool deletion_protection: The deletion protection of bandwidth package.
        :param str description: The description of the Common Bandwidth Package instance.
        :param str expired_time: The expired time of bandwidth package.
        :param bool has_reservation_data: Is has reservation data.
        :param str id: ID of the Common Bandwidth Package.
        :param str internet_charge_type: The internet charge type of bandwidth package.
        :param str isp: ISP of the Common Bandwidth Package.
        :param str name: Name of the Common Bandwidth Package.
        :param str payment_type: The payment type of bandwidth package.
        :param Sequence['GetCommonBandwidthPackagesPackagePublicIpAddressArgs'] public_ip_addresses: Public ip addresses that in the Common Bandwidth Pakcage.
        :param int ratio: The ratio of bandwidth package.
        :param str reservation_active_time: The active time of reservation.
        :param str reservation_bandwidth: The bandwidth of reservation.
        :param str reservation_internet_charge_type: The charge type of reservation internet.
        :param str reservation_order_type: The type of reservation order.
        :param str resource_group_id: The Id of resource group which the common bandwidth package belongs.
        :param int service_managed: The service managed.
        :param str status: The status of bandwidth package. Valid values: `Available` and `Pending`.
        """
        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__, "business_status", business_status)
        pulumi.set(__self__, "deletion_protection", deletion_protection)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "expired_time", expired_time)
        pulumi.set(__self__, "has_reservation_data", has_reservation_data)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internet_charge_type", internet_charge_type)
        pulumi.set(__self__, "isp", isp)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "public_ip_addresses", public_ip_addresses)
        pulumi.set(__self__, "ratio", ratio)
        pulumi.set(__self__, "reservation_active_time", reservation_active_time)
        pulumi.set(__self__, "reservation_bandwidth", reservation_bandwidth)
        pulumi.set(__self__, "reservation_internet_charge_type", reservation_internet_charge_type)
        pulumi.set(__self__, "reservation_order_type", reservation_order_type)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "service_managed", service_managed)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def bandwidth(self) -> str:
        """
        The peak bandwidth of the Internet Shared Bandwidth instance.
        """
        return pulumi.get(self, "bandwidth")

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

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

    @property
    @pulumi.getter(name="businessStatus")
    def business_status(self) -> str:
        """
        The business status of the Common Bandwidth Package instance.
        """
        return pulumi.get(self, "business_status")

    @property
    @pulumi.getter(name="deletionProtection")
    def deletion_protection(self) -> bool:
        """
        The deletion protection of bandwidth package.
        """
        return pulumi.get(self, "deletion_protection")

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

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> str:
        """
        The expired time of bandwidth package.
        """
        return pulumi.get(self, "expired_time")

    @property
    @pulumi.getter(name="hasReservationData")
    def has_reservation_data(self) -> bool:
        """
        Is has reservation data.
        """
        return pulumi.get(self, "has_reservation_data")

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

    @property
    @pulumi.getter(name="internetChargeType")
    def internet_charge_type(self) -> str:
        """
        The internet charge type of bandwidth package.
        """
        return pulumi.get(self, "internet_charge_type")

    @property
    @pulumi.getter
    def isp(self) -> str:
        """
        ISP of the Common Bandwidth Package.
        """
        return pulumi.get(self, "isp")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the Common Bandwidth Package.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="publicIpAddresses")
    def public_ip_addresses(self) -> Sequence['outputs.GetCommonBandwidthPackagesPackagePublicIpAddressResult']:
        """
        Public ip addresses that in the Common Bandwidth Pakcage.
        """
        return pulumi.get(self, "public_ip_addresses")

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

    @property
    @pulumi.getter(name="reservationActiveTime")
    def reservation_active_time(self) -> str:
        """
        The active time of reservation.
        """
        return pulumi.get(self, "reservation_active_time")

    @property
    @pulumi.getter(name="reservationBandwidth")
    def reservation_bandwidth(self) -> str:
        """
        The bandwidth of reservation.
        """
        return pulumi.get(self, "reservation_bandwidth")

    @property
    @pulumi.getter(name="reservationInternetChargeType")
    def reservation_internet_charge_type(self) -> str:
        """
        The charge type of reservation internet.
        """
        return pulumi.get(self, "reservation_internet_charge_type")

    @property
    @pulumi.getter(name="reservationOrderType")
    def reservation_order_type(self) -> str:
        """
        The type of reservation order.
        """
        return pulumi.get(self, "reservation_order_type")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which the common bandwidth package belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="serviceManaged")
    def service_managed(self) -> int:
        """
        The service managed.
        """
        return pulumi.get(self, "service_managed")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of bandwidth package. Valid values: `Available` and `Pending`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetCommonBandwidthPackagesPackagePublicIpAddressResult(dict):
    def __init__(__self__, *,
                 allocation_id: str,
                 bandwidth_package_ip_relation_status: str,
                 ip_address: str):
        pulumi.set(__self__, "allocation_id", allocation_id)
        pulumi.set(__self__, "bandwidth_package_ip_relation_status", bandwidth_package_ip_relation_status)
        pulumi.set(__self__, "ip_address", ip_address)

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

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

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


@pulumi.output_type
class GetDhcpOptionsSetsSetResult(dict):
    def __init__(__self__, *,
                 associate_vpcs: Sequence['outputs.GetDhcpOptionsSetsSetAssociateVpcResult'],
                 dhcp_options_set_description: str,
                 dhcp_options_set_id: str,
                 dhcp_options_set_name: str,
                 domain_name: str,
                 domain_name_servers: str,
                 id: str,
                 owner_id: str,
                 status: str):
        """
        :param Sequence['GetDhcpOptionsSetsSetAssociateVpcArgs'] associate_vpcs: AssociateVpcs.
        :param str dhcp_options_set_description: The description of the DHCP options set. The description must be 2 to 256
               characters in length and cannot start with `http://` or `https://`.
        :param str dhcp_options_set_name: The root domain, for example, example.com. After a DHCP options set is associated with a
               Virtual Private Cloud (VPC) network, the root domain in the DHCP options set is automatically synchronized to the
               ECS instances in the VPC network.
        :param str domain_name: The root domain, for example, example.com. After a DHCP options set is associated with a Virtual
               Private Cloud (VPC) network, the root domain in the DHCP options set is automatically synchronized to the ECS
               instances in the VPC network.
        :param str domain_name_servers: The DNS server IP addresses. Up to four DNS server IP addresses can be specified. IP
               addresses must be separated with commas (,).
        :param str owner_id: The ID of the account to which the DHCP options set belongs.
        :param str status: The status of the DHCP options set. Valid values: `Available`, `InUse` or `Pending`. `Available`: The DHCP options set is available for use. `InUse`: The DHCP options set is in use. `Pending`: The DHCP options set is being configured.
        """
        pulumi.set(__self__, "associate_vpcs", associate_vpcs)
        pulumi.set(__self__, "dhcp_options_set_description", dhcp_options_set_description)
        pulumi.set(__self__, "dhcp_options_set_id", dhcp_options_set_id)
        pulumi.set(__self__, "dhcp_options_set_name", dhcp_options_set_name)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "domain_name_servers", domain_name_servers)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "owner_id", owner_id)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="associateVpcs")
    def associate_vpcs(self) -> Sequence['outputs.GetDhcpOptionsSetsSetAssociateVpcResult']:
        """
        AssociateVpcs.
        """
        return pulumi.get(self, "associate_vpcs")

    @property
    @pulumi.getter(name="dhcpOptionsSetDescription")
    def dhcp_options_set_description(self) -> str:
        """
        The description of the DHCP options set. The description must be 2 to 256
        characters in length and cannot start with `http://` or `https://`.
        """
        return pulumi.get(self, "dhcp_options_set_description")

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

    @property
    @pulumi.getter(name="dhcpOptionsSetName")
    def dhcp_options_set_name(self) -> str:
        """
        The root domain, for example, example.com. After a DHCP options set is associated with a
        Virtual Private Cloud (VPC) network, the root domain in the DHCP options set is automatically synchronized to the
        ECS instances in the VPC network.
        """
        return pulumi.get(self, "dhcp_options_set_name")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        """
        The root domain, for example, example.com. After a DHCP options set is associated with a Virtual
        Private Cloud (VPC) network, the root domain in the DHCP options set is automatically synchronized to the ECS
        instances in the VPC network.
        """
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter(name="domainNameServers")
    def domain_name_servers(self) -> str:
        """
        The DNS server IP addresses. Up to four DNS server IP addresses can be specified. IP
        addresses must be separated with commas (,).
        """
        return pulumi.get(self, "domain_name_servers")

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

    @property
    @pulumi.getter(name="ownerId")
    def owner_id(self) -> str:
        """
        The ID of the account to which the DHCP options set belongs.
        """
        return pulumi.get(self, "owner_id")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the DHCP options set. Valid values: `Available`, `InUse` or `Pending`. `Available`: The DHCP options set is available for use. `InUse`: The DHCP options set is in use. `Pending`: The DHCP options set is being configured.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetDhcpOptionsSetsSetAssociateVpcResult(dict):
    def __init__(__self__, *,
                 associate_status: str,
                 vpc_id: str):
        """
        :param str associate_status: The status of the VPC network that is associated with the DHCP options set. Valid values:`InUse` or `Pending`. `InUse`: The VPC network is in use. `Pending`: The VPC network is being configured.
        :param str vpc_id: The ID of the VPC network that is associated with the DHCP options set.
        """
        pulumi.set(__self__, "associate_status", associate_status)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="associateStatus")
    def associate_status(self) -> str:
        """
        The status of the VPC network that is associated with the DHCP options set. Valid values:`InUse` or `Pending`. `InUse`: The VPC network is in use. `Pending`: The VPC network is being configured.
        """
        return pulumi.get(self, "associate_status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The ID of the VPC network that is associated with the DHCP options set.
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class GetEnhancedNatAvailableZonesZoneResult(dict):
    def __init__(__self__, *,
                 local_name: str,
                 zone_id: str):
        pulumi.set(__self__, "local_name", local_name)
        pulumi.set(__self__, "zone_id", zone_id)

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

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


@pulumi.output_type
class GetForwardEntriesEntryResult(dict):
    def __init__(__self__, *,
                 external_ip: str,
                 external_port: str,
                 forward_entry_id: str,
                 forward_entry_name: str,
                 id: str,
                 internal_ip: str,
                 internal_port: str,
                 ip_protocol: str,
                 name: str,
                 status: str):
        """
        :param str external_ip: The public IP address.
        :param str external_port: The public port.
        :param str forward_entry_id: The forward entry ID.
        :param str forward_entry_name: The name of forward entry.
        :param str id: The ID of the Forward Entry.
        :param str internal_ip: The private IP address.
        :param str internal_port: The internal port.
        :param str ip_protocol: The ip protocol. Valid values: `any`,`tcp` and `udp`.
        :param str name: The forward entry name.
        :param str status: The status of farward entry. Valid value `Available`, `Deleting` and `Pending`.
        """
        pulumi.set(__self__, "external_ip", external_ip)
        pulumi.set(__self__, "external_port", external_port)
        pulumi.set(__self__, "forward_entry_id", forward_entry_id)
        pulumi.set(__self__, "forward_entry_name", forward_entry_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internal_ip", internal_ip)
        pulumi.set(__self__, "internal_port", internal_port)
        pulumi.set(__self__, "ip_protocol", ip_protocol)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="externalIp")
    def external_ip(self) -> str:
        """
        The public IP address.
        """
        return pulumi.get(self, "external_ip")

    @property
    @pulumi.getter(name="externalPort")
    def external_port(self) -> str:
        """
        The public port.
        """
        return pulumi.get(self, "external_port")

    @property
    @pulumi.getter(name="forwardEntryId")
    def forward_entry_id(self) -> str:
        """
        The forward entry ID.
        """
        return pulumi.get(self, "forward_entry_id")

    @property
    @pulumi.getter(name="forwardEntryName")
    def forward_entry_name(self) -> str:
        """
        The name of forward entry.
        """
        return pulumi.get(self, "forward_entry_name")

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

    @property
    @pulumi.getter(name="internalIp")
    def internal_ip(self) -> str:
        """
        The private IP address.
        """
        return pulumi.get(self, "internal_ip")

    @property
    @pulumi.getter(name="internalPort")
    def internal_port(self) -> str:
        """
        The internal port.
        """
        return pulumi.get(self, "internal_port")

    @property
    @pulumi.getter(name="ipProtocol")
    def ip_protocol(self) -> str:
        """
        The ip protocol. Valid values: `any`,`tcp` and `udp`.
        """
        return pulumi.get(self, "ip_protocol")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The forward entry name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of farward entry. Valid value `Available`, `Deleting` and `Pending`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetHavipsHavipResult(dict):
    def __init__(__self__, *,
                 associated_eip_addresses: Sequence[str],
                 associated_instances: Sequence[str],
                 description: str,
                 havip_id: str,
                 havip_name: str,
                 id: str,
                 ip_address: str,
                 master_instance_id: str,
                 status: str,
                 vpc_id: str,
                 vswitch_id: str):
        """
        :param Sequence[str] associated_eip_addresses: EIP bound to HaVip.
        :param Sequence[str] associated_instances: An ECS instance that is bound to HaVip.
        :param str description: Dependence of a HaVip instance.
        :param str havip_id: The  ID of the resource.
        :param str havip_name: The name of the HaVip instance.
        :param str id: The ID of the Ha Vip.
        :param str ip_address: IP address of private network.
        :param str master_instance_id: The primary instance ID bound to HaVip.
        :param str status: The status.
        :param str vpc_id: The VPC ID to which the HaVip instance belongs.
        :param str vswitch_id: The vswitch id.
        """
        pulumi.set(__self__, "associated_eip_addresses", associated_eip_addresses)
        pulumi.set(__self__, "associated_instances", associated_instances)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "havip_id", havip_id)
        pulumi.set(__self__, "havip_name", havip_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ip_address", ip_address)
        pulumi.set(__self__, "master_instance_id", master_instance_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_id", vswitch_id)

    @property
    @pulumi.getter(name="associatedEipAddresses")
    def associated_eip_addresses(self) -> Sequence[str]:
        """
        EIP bound to HaVip.
        """
        return pulumi.get(self, "associated_eip_addresses")

    @property
    @pulumi.getter(name="associatedInstances")
    def associated_instances(self) -> Sequence[str]:
        """
        An ECS instance that is bound to HaVip.
        """
        return pulumi.get(self, "associated_instances")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Dependence of a HaVip instance.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="havipId")
    def havip_id(self) -> str:
        """
        The  ID of the resource.
        """
        return pulumi.get(self, "havip_id")

    @property
    @pulumi.getter(name="havipName")
    def havip_name(self) -> str:
        """
        The name of the HaVip instance.
        """
        return pulumi.get(self, "havip_name")

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

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> str:
        """
        IP address of private network.
        """
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="masterInstanceId")
    def master_instance_id(self) -> str:
        """
        The primary instance ID bound to HaVip.
        """
        return pulumi.get(self, "master_instance_id")

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

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The VPC ID to which the HaVip instance belongs.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        The vswitch id.
        """
        return pulumi.get(self, "vswitch_id")


@pulumi.output_type
class GetIpv6AddressesAddressResult(dict):
    def __init__(__self__, *,
                 associated_instance_id: str,
                 associated_instance_type: str,
                 create_time: str,
                 id: str,
                 ipv6_address: str,
                 ipv6_address_id: str,
                 ipv6_address_name: str,
                 ipv6_gateway_id: str,
                 network_type: str,
                 status: str,
                 vpc_id: str,
                 vswitch_id: str):
        """
        :param str associated_instance_id: The ID of the instance that is assigned the IPv6 address.
        :param str associated_instance_type: The type of the instance that is assigned the IPv6 address.
        :param str create_time: The time when the IPv6 address was created.
        :param str id: The ID of the Ipv6 Address.
        :param str ipv6_address: The address of the Ipv6 Address.
        :param str ipv6_address_id: The ID of the IPv6 address.
        :param str ipv6_address_name: The name of the IPv6 address.
        :param str ipv6_gateway_id: The ID of the IPv6 gateway to which the IPv6 address belongs.
        :param str network_type: The type of communication supported by the IPv6 address. Valid values:`Private` or `Public`. `Private`: communication within the private network. `Public`: communication over the public network
        :param str status: The status of the IPv6 address. Valid values:`Pending` or `Available`.
        :param str vpc_id: The ID of the VPC to which the IPv6 address belongs.
        :param str vswitch_id: The ID of the vSwitch to which the IPv6 address belongs.
        """
        pulumi.set(__self__, "associated_instance_id", associated_instance_id)
        pulumi.set(__self__, "associated_instance_type", associated_instance_type)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ipv6_address", ipv6_address)
        pulumi.set(__self__, "ipv6_address_id", ipv6_address_id)
        pulumi.set(__self__, "ipv6_address_name", ipv6_address_name)
        pulumi.set(__self__, "ipv6_gateway_id", ipv6_gateway_id)
        pulumi.set(__self__, "network_type", network_type)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_id", vswitch_id)

    @property
    @pulumi.getter(name="associatedInstanceId")
    def associated_instance_id(self) -> str:
        """
        The ID of the instance that is assigned the IPv6 address.
        """
        return pulumi.get(self, "associated_instance_id")

    @property
    @pulumi.getter(name="associatedInstanceType")
    def associated_instance_type(self) -> str:
        """
        The type of the instance that is assigned the IPv6 address.
        """
        return pulumi.get(self, "associated_instance_type")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The time when the IPv6 address was created.
        """
        return pulumi.get(self, "create_time")

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

    @property
    @pulumi.getter(name="ipv6Address")
    def ipv6_address(self) -> str:
        """
        The address of the Ipv6 Address.
        """
        return pulumi.get(self, "ipv6_address")

    @property
    @pulumi.getter(name="ipv6AddressId")
    def ipv6_address_id(self) -> str:
        """
        The ID of the IPv6 address.
        """
        return pulumi.get(self, "ipv6_address_id")

    @property
    @pulumi.getter(name="ipv6AddressName")
    def ipv6_address_name(self) -> str:
        """
        The name of the IPv6 address.
        """
        return pulumi.get(self, "ipv6_address_name")

    @property
    @pulumi.getter(name="ipv6GatewayId")
    def ipv6_gateway_id(self) -> str:
        """
        The ID of the IPv6 gateway to which the IPv6 address belongs.
        """
        return pulumi.get(self, "ipv6_gateway_id")

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> str:
        """
        The type of communication supported by the IPv6 address. Valid values:`Private` or `Public`. `Private`: communication within the private network. `Public`: communication over the public network
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the IPv6 address. Valid values:`Pending` or `Available`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The ID of the VPC to which the IPv6 address belongs.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        The ID of the vSwitch to which the IPv6 address belongs.
        """
        return pulumi.get(self, "vswitch_id")


@pulumi.output_type
class GetIpv6EgressRulesRuleResult(dict):
    def __init__(__self__, *,
                 description: str,
                 id: str,
                 instance_id: str,
                 instance_type: str,
                 ipv6_egress_rule_id: str,
                 ipv6_egress_rule_name: str,
                 ipv6_gateway_id: str,
                 status: str):
        """
        :param str description: The description of the egress-only rule.
        :param str id: The ID of the Ipv6 Egress Rule. The value formats as `<ipv6_gateway_id>:<ipv6_egress_rule_id>`.
        :param str instance_id: The ID of the instance to which the egress-only rule is applied.
        :param str instance_type: The type of the instance to which the egress-only rule is applied.
        :param str ipv6_egress_rule_id: The first ID of the resource.
        :param str ipv6_egress_rule_name: The name of the resource.
        :param str ipv6_gateway_id: The ID of the IPv6 gateway.
        :param str status: The status of the resource. Valid values: `Available`, `Pending` and `Deleting`.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "ipv6_egress_rule_id", ipv6_egress_rule_id)
        pulumi.set(__self__, "ipv6_egress_rule_name", ipv6_egress_rule_name)
        pulumi.set(__self__, "ipv6_gateway_id", ipv6_gateway_id)
        pulumi.set(__self__, "status", status)

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Ipv6 Egress Rule. The value formats as `<ipv6_gateway_id>:<ipv6_egress_rule_id>`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        The ID of the instance to which the egress-only rule is applied.
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> str:
        """
        The type of the instance to which the egress-only rule is applied.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="ipv6EgressRuleId")
    def ipv6_egress_rule_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "ipv6_egress_rule_id")

    @property
    @pulumi.getter(name="ipv6EgressRuleName")
    def ipv6_egress_rule_name(self) -> str:
        """
        The name of the resource.
        """
        return pulumi.get(self, "ipv6_egress_rule_name")

    @property
    @pulumi.getter(name="ipv6GatewayId")
    def ipv6_gateway_id(self) -> str:
        """
        The ID of the IPv6 gateway.
        """
        return pulumi.get(self, "ipv6_gateway_id")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the resource. Valid values: `Available`, `Pending` and `Deleting`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetIpv6GatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 business_status: str,
                 create_time: str,
                 description: str,
                 expired_time: str,
                 id: str,
                 instance_charge_type: str,
                 ipv6_gateway_id: str,
                 ipv6_gateway_name: str,
                 spec: str,
                 status: str,
                 vpc_id: str):
        """
        :param str business_status: The status of the IPv6 gateway. Valid values:`Normal`, `FinancialLocked` and `SecurityLocked`. `Normal`: working as expected. `FinancialLocked`: locked due to overdue payments. `SecurityLocked`: locked due to security reasons.
        :param str create_time: The creation time of the resource.
        :param str description: The description of the IPv6 gateway.
        :param str expired_time: The time when the IPv6 gateway expires.
        :param str id: The ID of the Ipv6 Gateway.
        :param str instance_charge_type: The metering method of the IPv6 gateway. Valid values: `PayAsYouGo`.
        :param str ipv6_gateway_id: The first ID of the resource.
        :param str ipv6_gateway_name: The name of the IPv6 gateway.
        :param str spec: The specification of the IPv6 gateway. Valid values: `Large`, `Medium` and `Small`. `Small` (default): Free Edition. `Medium`: Enterprise Edition . `Large`: Enhanced Enterprise Edition. The throughput capacity of an IPv6 gateway varies based on the edition. For more information, see [Editions of IPv6 gateways](https://www.alibabacloud.com/help/doc-detail/98926.htm).
        :param str status: The status of the IPv6 gateway. Valid values: `Available`, `Deleting`, `Pending`.
        :param str vpc_id: The ID of the virtual private cloud (VPC) to which the IPv6 gateway belongs.
        """
        pulumi.set(__self__, "business_status", business_status)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "expired_time", expired_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "instance_charge_type", instance_charge_type)
        pulumi.set(__self__, "ipv6_gateway_id", ipv6_gateway_id)
        pulumi.set(__self__, "ipv6_gateway_name", ipv6_gateway_name)
        pulumi.set(__self__, "spec", spec)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="businessStatus")
    def business_status(self) -> str:
        """
        The status of the IPv6 gateway. Valid values:`Normal`, `FinancialLocked` and `SecurityLocked`. `Normal`: working as expected. `FinancialLocked`: locked due to overdue payments. `SecurityLocked`: locked due to security reasons.
        """
        return pulumi.get(self, "business_status")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The creation time of the resource.
        """
        return pulumi.get(self, "create_time")

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

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> str:
        """
        The time when the IPv6 gateway expires.
        """
        return pulumi.get(self, "expired_time")

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

    @property
    @pulumi.getter(name="instanceChargeType")
    def instance_charge_type(self) -> str:
        """
        The metering method of the IPv6 gateway. Valid values: `PayAsYouGo`.
        """
        return pulumi.get(self, "instance_charge_type")

    @property
    @pulumi.getter(name="ipv6GatewayId")
    def ipv6_gateway_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "ipv6_gateway_id")

    @property
    @pulumi.getter(name="ipv6GatewayName")
    def ipv6_gateway_name(self) -> str:
        """
        The name of the IPv6 gateway.
        """
        return pulumi.get(self, "ipv6_gateway_name")

    @property
    @pulumi.getter
    def spec(self) -> str:
        """
        The specification of the IPv6 gateway. Valid values: `Large`, `Medium` and `Small`. `Small` (default): Free Edition. `Medium`: Enterprise Edition . `Large`: Enhanced Enterprise Edition. The throughput capacity of an IPv6 gateway varies based on the edition. For more information, see [Editions of IPv6 gateways](https://www.alibabacloud.com/help/doc-detail/98926.htm).
        """
        return pulumi.get(self, "spec")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the IPv6 gateway. Valid values: `Available`, `Deleting`, `Pending`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The ID of the virtual private cloud (VPC) to which the IPv6 gateway belongs.
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class GetIpv6InternetBandwidthsBandwidthResult(dict):
    def __init__(__self__, *,
                 bandwidth: int,
                 id: str,
                 internet_charge_type: str,
                 ipv6_address_id: str,
                 ipv6_gateway_id: str,
                 ipv6_internet_bandwidth_id: str,
                 payment_type: str,
                 status: str):
        """
        :param int bandwidth: The amount of Internet bandwidth resources of the IPv6 address, Unit: `Mbit/s`.
        :param str id: The ID of the Ipv6 Internet Bandwidth.
        :param str internet_charge_type: The metering method of the Internet bandwidth resources of the IPv6 gateway.
        :param str ipv6_address_id: The ID of the IPv6 address.
        :param str ipv6_gateway_id: The ID of the IPv6 gateway.
        :param str ipv6_internet_bandwidth_id: The ID of the Ipv6 Internet Bandwidth.
        :param str payment_type: The payment type of the resource.
        :param str status: The status of the resource. Valid values: `Normal`, `FinancialLocked` and `SecurityLocked`.
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internet_charge_type", internet_charge_type)
        pulumi.set(__self__, "ipv6_address_id", ipv6_address_id)
        pulumi.set(__self__, "ipv6_gateway_id", ipv6_gateway_id)
        pulumi.set(__self__, "ipv6_internet_bandwidth_id", ipv6_internet_bandwidth_id)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def bandwidth(self) -> int:
        """
        The amount of Internet bandwidth resources of the IPv6 address, Unit: `Mbit/s`.
        """
        return pulumi.get(self, "bandwidth")

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

    @property
    @pulumi.getter(name="internetChargeType")
    def internet_charge_type(self) -> str:
        """
        The metering method of the Internet bandwidth resources of the IPv6 gateway.
        """
        return pulumi.get(self, "internet_charge_type")

    @property
    @pulumi.getter(name="ipv6AddressId")
    def ipv6_address_id(self) -> str:
        """
        The ID of the IPv6 address.
        """
        return pulumi.get(self, "ipv6_address_id")

    @property
    @pulumi.getter(name="ipv6GatewayId")
    def ipv6_gateway_id(self) -> str:
        """
        The ID of the IPv6 gateway.
        """
        return pulumi.get(self, "ipv6_gateway_id")

    @property
    @pulumi.getter(name="ipv6InternetBandwidthId")
    def ipv6_internet_bandwidth_id(self) -> str:
        """
        The ID of the Ipv6 Internet Bandwidth.
        """
        return pulumi.get(self, "ipv6_internet_bandwidth_id")

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

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the resource. Valid values: `Normal`, `FinancialLocked` and `SecurityLocked`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetNatGatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 business_status: str,
                 deletion_protection: bool,
                 description: str,
                 ecs_metric_enabled: bool,
                 expired_time: str,
                 forward_table_ids: Sequence[str],
                 id: str,
                 internet_charge_type: str,
                 ip_lists: Sequence[str],
                 name: str,
                 nat_gateway_id: str,
                 nat_gateway_name: str,
                 nat_type: str,
                 network_type: str,
                 payment_type: str,
                 resource_group_id: str,
                 snat_table_ids: Sequence[str],
                 spec: str,
                 specification: str,
                 status: str,
                 tags: Mapping[str, Any],
                 vpc_id: str,
                 vswitch_id: str):
        """
        :param str business_status: The state of the NAT gateway.
        :param bool deletion_protection: Indicates whether deletion protection is enabled.
        :param str description: The description of the NAT gateway.
        :param bool ecs_metric_enabled: Indicates whether the traffic monitoring feature is enabled.
        :param str expired_time: The time when the NAT gateway expires.
        :param Sequence[str] forward_table_ids: The ID of the DNAT table.
        :param str id: The ID of the NAT gateway.
        :param str internet_charge_type: The metering method of the NAT gateway.
        :param Sequence[str] ip_lists: The ip address of the bind eip.
        :param str name: Name of the NAT gateway.
        :param str nat_gateway_id: The ID of the NAT gateway.
        :param str nat_gateway_name: The name of NAT gateway.
        :param str nat_type: The nat type of NAT gateway. Valid values `Enhanced` and `Normal`.
        :param str network_type: (Available in 1.137.0+) Indicates the type of the created NAT gateway. Valid values `internet` and `intranet`.
        :param str payment_type: The payment type of NAT gateway. Valid values `PayAsYouGo` and `Subscription`.
        :param str resource_group_id: The resource group id of NAT gateway.
        :param Sequence[str] snat_table_ids: The ID of the SNAT table that is associated with the NAT gateway.
        :param str spec: The specification of the NAT gateway.
        :param str specification: The specification of NAT gateway. Valid values `Middle`, `Large`, `Small` and `XLarge.1`. Default value is `Small`.
        :param str status: The status of NAT gateway. Valid values `Available`, `Converting`, `Creating`, `Deleting` and `Modifying`.
        :param Mapping[str, Any] tags: The tags of NAT gateway.
        :param str vpc_id: The ID of the VPC.
        :param str vswitch_id: The ID of the vSwitch to which the NAT gateway belongs.
        """
        pulumi.set(__self__, "business_status", business_status)
        pulumi.set(__self__, "deletion_protection", deletion_protection)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "ecs_metric_enabled", ecs_metric_enabled)
        pulumi.set(__self__, "expired_time", expired_time)
        pulumi.set(__self__, "forward_table_ids", forward_table_ids)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internet_charge_type", internet_charge_type)
        pulumi.set(__self__, "ip_lists", ip_lists)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "nat_gateway_id", nat_gateway_id)
        pulumi.set(__self__, "nat_gateway_name", nat_gateway_name)
        pulumi.set(__self__, "nat_type", nat_type)
        pulumi.set(__self__, "network_type", network_type)
        pulumi.set(__self__, "payment_type", payment_type)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "snat_table_ids", snat_table_ids)
        pulumi.set(__self__, "spec", spec)
        pulumi.set(__self__, "specification", specification)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_id", vswitch_id)

    @property
    @pulumi.getter(name="businessStatus")
    def business_status(self) -> str:
        """
        The state of the NAT gateway.
        """
        return pulumi.get(self, "business_status")

    @property
    @pulumi.getter(name="deletionProtection")
    def deletion_protection(self) -> bool:
        """
        Indicates whether deletion protection is enabled.
        """
        return pulumi.get(self, "deletion_protection")

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

    @property
    @pulumi.getter(name="ecsMetricEnabled")
    def ecs_metric_enabled(self) -> bool:
        """
        Indicates whether the traffic monitoring feature is enabled.
        """
        return pulumi.get(self, "ecs_metric_enabled")

    @property
    @pulumi.getter(name="expiredTime")
    def expired_time(self) -> str:
        """
        The time when the NAT gateway expires.
        """
        return pulumi.get(self, "expired_time")

    @property
    @pulumi.getter(name="forwardTableIds")
    def forward_table_ids(self) -> Sequence[str]:
        """
        The ID of the DNAT table.
        """
        return pulumi.get(self, "forward_table_ids")

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

    @property
    @pulumi.getter(name="internetChargeType")
    def internet_charge_type(self) -> str:
        """
        The metering method of the NAT gateway.
        """
        return pulumi.get(self, "internet_charge_type")

    @property
    @pulumi.getter(name="ipLists")
    def ip_lists(self) -> Sequence[str]:
        """
        The ip address of the bind eip.
        """
        return pulumi.get(self, "ip_lists")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the NAT gateway.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="natGatewayId")
    def nat_gateway_id(self) -> str:
        """
        The ID of the NAT gateway.
        """
        return pulumi.get(self, "nat_gateway_id")

    @property
    @pulumi.getter(name="natGatewayName")
    def nat_gateway_name(self) -> str:
        """
        The name of NAT gateway.
        """
        return pulumi.get(self, "nat_gateway_name")

    @property
    @pulumi.getter(name="natType")
    def nat_type(self) -> str:
        """
        The nat type of NAT gateway. Valid values `Enhanced` and `Normal`.
        """
        return pulumi.get(self, "nat_type")

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> str:
        """
        (Available in 1.137.0+) Indicates the type of the created NAT gateway. Valid values `internet` and `intranet`.
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter(name="paymentType")
    def payment_type(self) -> str:
        """
        The payment type of NAT gateway. Valid values `PayAsYouGo` and `Subscription`.
        """
        return pulumi.get(self, "payment_type")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The resource group id of NAT gateway.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="snatTableIds")
    def snat_table_ids(self) -> Sequence[str]:
        """
        The ID of the SNAT table that is associated with the NAT gateway.
        """
        return pulumi.get(self, "snat_table_ids")

    @property
    @pulumi.getter
    def spec(self) -> str:
        """
        The specification of the NAT gateway.
        """
        return pulumi.get(self, "spec")

    @property
    @pulumi.getter
    def specification(self) -> str:
        """
        The specification of NAT gateway. Valid values `Middle`, `Large`, `Small` and `XLarge.1`. Default value is `Small`.
        """
        return pulumi.get(self, "specification")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of NAT gateway. Valid values `Available`, `Converting`, `Creating`, `Deleting` and `Modifying`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, Any]:
        """
        The tags of NAT gateway.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The ID of the VPC.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        The ID of the vSwitch to which the NAT gateway belongs.
        """
        return pulumi.get(self, "vswitch_id")


@pulumi.output_type
class GetNatIpCidrsCidrResult(dict):
    def __init__(__self__, *,
                 create_time: str,
                 id: str,
                 is_default: bool,
                 nat_gateway_id: str,
                 nat_ip_cidr: str,
                 nat_ip_cidr_description: str,
                 nat_ip_cidr_id: str,
                 nat_ip_cidr_name: str,
                 status: str):
        """
        :param str create_time: The time when the CIDR block was created.
        :param str id: The ID of the Nat Ip Cidr.
        :param bool is_default: Whether it is the default NAT IP ADDRESS. Valid values:`true` or `false`.`true`: is the default NAT IP ADDRESS. `false`: it is not the default NAT IP ADDRESS.
        :param str nat_gateway_id: The ID of the VPC NAT gateway.
        :param str nat_ip_cidr: The NAT CIDR block to be created. The CIDR block must meet the following conditions: It must be `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, or one of their subnets. The subnet mask must be `16` to `32` bits in lengths. To use a public CIDR block as the NAT CIDR block, the VPC to which the VPC NAT gateway belongs must be authorized to use public CIDR blocks. For more information, see [Create a VPC NAT gateway](https://www.alibabacloud.com/help/doc-detail/268230.htm).
        :param str nat_ip_cidr_description: NAT IP ADDRESS range to the description of. Length is from `2` to `256` characters, must start with a letter or the Chinese at the beginning, but not at the` http://` Or `https://` at the beginning.
        :param str nat_ip_cidr_id: NAT IP ADDRESS instance ID.
        :param str nat_ip_cidr_name: NAT IP ADDRESS the name of the root directory. Length is from `2` to `128` characters, must start with a letter or the Chinese at the beginning can contain numbers, half a period (.), underscore (_) and dash (-). But do not start with `http://` or `https://` at the beginning.
        :param str status: The status of the CIDR block of the NAT gateway. If the value is `Available`, the CIDR block is available.
        """
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "nat_gateway_id", nat_gateway_id)
        pulumi.set(__self__, "nat_ip_cidr", nat_ip_cidr)
        pulumi.set(__self__, "nat_ip_cidr_description", nat_ip_cidr_description)
        pulumi.set(__self__, "nat_ip_cidr_id", nat_ip_cidr_id)
        pulumi.set(__self__, "nat_ip_cidr_name", nat_ip_cidr_name)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The time when the CIDR block was created.
        """
        return pulumi.get(self, "create_time")

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

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Whether it is the default NAT IP ADDRESS. Valid values:`true` or `false`.`true`: is the default NAT IP ADDRESS. `false`: it is not the default NAT IP ADDRESS.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="natGatewayId")
    def nat_gateway_id(self) -> str:
        """
        The ID of the VPC NAT gateway.
        """
        return pulumi.get(self, "nat_gateway_id")

    @property
    @pulumi.getter(name="natIpCidr")
    def nat_ip_cidr(self) -> str:
        """
        The NAT CIDR block to be created. The CIDR block must meet the following conditions: It must be `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, or one of their subnets. The subnet mask must be `16` to `32` bits in lengths. To use a public CIDR block as the NAT CIDR block, the VPC to which the VPC NAT gateway belongs must be authorized to use public CIDR blocks. For more information, see [Create a VPC NAT gateway](https://www.alibabacloud.com/help/doc-detail/268230.htm).
        """
        return pulumi.get(self, "nat_ip_cidr")

    @property
    @pulumi.getter(name="natIpCidrDescription")
    def nat_ip_cidr_description(self) -> str:
        """
        NAT IP ADDRESS range to the description of. Length is from `2` to `256` characters, must start with a letter or the Chinese at the beginning, but not at the` http://` Or `https://` at the beginning.
        """
        return pulumi.get(self, "nat_ip_cidr_description")

    @property
    @pulumi.getter(name="natIpCidrId")
    def nat_ip_cidr_id(self) -> str:
        """
        NAT IP ADDRESS instance ID.
        """
        return pulumi.get(self, "nat_ip_cidr_id")

    @property
    @pulumi.getter(name="natIpCidrName")
    def nat_ip_cidr_name(self) -> str:
        """
        NAT IP ADDRESS the name of the root directory. Length is from `2` to `128` characters, must start with a letter or the Chinese at the beginning can contain numbers, half a period (.), underscore (_) and dash (-). But do not start with `http://` or `https://` at the beginning.
        """
        return pulumi.get(self, "nat_ip_cidr_name")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the CIDR block of the NAT gateway. If the value is `Available`, the CIDR block is available.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetNatIpsIpResult(dict):
    def __init__(__self__, *,
                 id: str,
                 is_default: bool,
                 nat_gateway_id: str,
                 nat_ip: str,
                 nat_ip_cidr: str,
                 nat_ip_description: str,
                 nat_ip_id: str,
                 nat_ip_name: str,
                 status: str):
        """
        :param str id: The ID of the Nat Ip.
        :param bool is_default: Indicates whether the BGP Group is the default NAT IP ADDRESS. Valid values: `true`: is the default NAT IP ADDRESS. `false`: it is not the default NAT IP ADDRESS.
        :param str nat_gateway_id: The ID of the Virtual Private Cloud (VPC) NAT gateway to which the NAT IP address belongs.
        :param str nat_ip: The NAT IP address that is queried.
        :param str nat_ip_cidr: The CIDR block to which the NAT IP address belongs.
        :param str nat_ip_description: The description of the NAT IP address.
        :param str nat_ip_id: The ID of the NAT IP address.
        :param str nat_ip_name: The name of the NAT IP address.
        :param str status: The status of the NAT IP address. Valid values: `Available`, `Deleting` and `Creating`.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "nat_gateway_id", nat_gateway_id)
        pulumi.set(__self__, "nat_ip", nat_ip)
        pulumi.set(__self__, "nat_ip_cidr", nat_ip_cidr)
        pulumi.set(__self__, "nat_ip_description", nat_ip_description)
        pulumi.set(__self__, "nat_ip_id", nat_ip_id)
        pulumi.set(__self__, "nat_ip_name", nat_ip_name)
        pulumi.set(__self__, "status", status)

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

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Indicates whether the BGP Group is the default NAT IP ADDRESS. Valid values: `true`: is the default NAT IP ADDRESS. `false`: it is not the default NAT IP ADDRESS.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="natGatewayId")
    def nat_gateway_id(self) -> str:
        """
        The ID of the Virtual Private Cloud (VPC) NAT gateway to which the NAT IP address belongs.
        """
        return pulumi.get(self, "nat_gateway_id")

    @property
    @pulumi.getter(name="natIp")
    def nat_ip(self) -> str:
        """
        The NAT IP address that is queried.
        """
        return pulumi.get(self, "nat_ip")

    @property
    @pulumi.getter(name="natIpCidr")
    def nat_ip_cidr(self) -> str:
        """
        The CIDR block to which the NAT IP address belongs.
        """
        return pulumi.get(self, "nat_ip_cidr")

    @property
    @pulumi.getter(name="natIpDescription")
    def nat_ip_description(self) -> str:
        """
        The description of the NAT IP address.
        """
        return pulumi.get(self, "nat_ip_description")

    @property
    @pulumi.getter(name="natIpId")
    def nat_ip_id(self) -> str:
        """
        The ID of the NAT IP address.
        """
        return pulumi.get(self, "nat_ip_id")

    @property
    @pulumi.getter(name="natIpName")
    def nat_ip_name(self) -> str:
        """
        The name of the NAT IP address.
        """
        return pulumi.get(self, "nat_ip_name")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the NAT IP address. Valid values: `Available`, `Deleting` and `Creating`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetNetworkAclsAclResult(dict):
    def __init__(__self__, *,
                 description: str,
                 egress_acl_entries: Sequence['outputs.GetNetworkAclsAclEgressAclEntryResult'],
                 id: str,
                 ingress_acl_entries: Sequence['outputs.GetNetworkAclsAclIngressAclEntryResult'],
                 network_acl_id: str,
                 network_acl_name: str,
                 resources: Sequence['outputs.GetNetworkAclsAclResourceResult'],
                 status: str,
                 vpc_id: str):
        """
        :param str description: Description of the entry direction rule.
        :param Sequence['GetNetworkAclsAclEgressAclEntryArgs'] egress_acl_entries: Output direction rule information.
        :param str id: The ID of the Network Acl.
        :param Sequence['GetNetworkAclsAclIngressAclEntryArgs'] ingress_acl_entries: Entry direction rule information.
        :param str network_acl_id: The first ID of the resource.
        :param str network_acl_name: The name of the network ACL.
        :param Sequence['GetNetworkAclsAclResourceArgs'] resources: The associated resource.
        :param str status: The state of the network ACL.
        :param str vpc_id: The ID of the associated VPC.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "egress_acl_entries", egress_acl_entries)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ingress_acl_entries", ingress_acl_entries)
        pulumi.set(__self__, "network_acl_id", network_acl_id)
        pulumi.set(__self__, "network_acl_name", network_acl_name)
        pulumi.set(__self__, "resources", resources)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description of the entry direction rule.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="egressAclEntries")
    def egress_acl_entries(self) -> Sequence['outputs.GetNetworkAclsAclEgressAclEntryResult']:
        """
        Output direction rule information.
        """
        return pulumi.get(self, "egress_acl_entries")

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

    @property
    @pulumi.getter(name="ingressAclEntries")
    def ingress_acl_entries(self) -> Sequence['outputs.GetNetworkAclsAclIngressAclEntryResult']:
        """
        Entry direction rule information.
        """
        return pulumi.get(self, "ingress_acl_entries")

    @property
    @pulumi.getter(name="networkAclId")
    def network_acl_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "network_acl_id")

    @property
    @pulumi.getter(name="networkAclName")
    def network_acl_name(self) -> str:
        """
        The name of the network ACL.
        """
        return pulumi.get(self, "network_acl_name")

    @property
    @pulumi.getter
    def resources(self) -> Sequence['outputs.GetNetworkAclsAclResourceResult']:
        """
        The associated resource.
        """
        return pulumi.get(self, "resources")

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

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The ID of the associated VPC.
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class GetNetworkAclsAclEgressAclEntryResult(dict):
    def __init__(__self__, *,
                 description: str,
                 destination_cidr_ip: str,
                 network_acl_entry_name: str,
                 policy: str,
                 port: str,
                 protocol: str):
        """
        :param str description: Description of the entry direction rule.
        :param str destination_cidr_ip: The destination address segment.
        :param str network_acl_entry_name: The name of the entry direction rule entry.
        :param str policy: The authorization policy.
        :param str port: Source port range.
        :param str protocol: Transport layer protocol.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "destination_cidr_ip", destination_cidr_ip)
        pulumi.set(__self__, "network_acl_entry_name", network_acl_entry_name)
        pulumi.set(__self__, "policy", policy)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description of the entry direction rule.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="destinationCidrIp")
    def destination_cidr_ip(self) -> str:
        """
        The destination address segment.
        """
        return pulumi.get(self, "destination_cidr_ip")

    @property
    @pulumi.getter(name="networkAclEntryName")
    def network_acl_entry_name(self) -> str:
        """
        The name of the entry direction rule entry.
        """
        return pulumi.get(self, "network_acl_entry_name")

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

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

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


@pulumi.output_type
class GetNetworkAclsAclIngressAclEntryResult(dict):
    def __init__(__self__, *,
                 description: str,
                 network_acl_entry_name: str,
                 policy: str,
                 port: str,
                 protocol: str,
                 source_cidr_ip: str):
        """
        :param str description: Description of the entry direction rule.
        :param str network_acl_entry_name: The name of the entry direction rule entry.
        :param str policy: The authorization policy.
        :param str port: Source port range.
        :param str protocol: Transport layer protocol.
        :param str source_cidr_ip: The source address field.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "network_acl_entry_name", network_acl_entry_name)
        pulumi.set(__self__, "policy", policy)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "source_cidr_ip", source_cidr_ip)

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        Description of the entry direction rule.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="networkAclEntryName")
    def network_acl_entry_name(self) -> str:
        """
        The name of the entry direction rule entry.
        """
        return pulumi.get(self, "network_acl_entry_name")

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

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

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

    @property
    @pulumi.getter(name="sourceCidrIp")
    def source_cidr_ip(self) -> str:
        """
        The source address field.
        """
        return pulumi.get(self, "source_cidr_ip")


@pulumi.output_type
class GetNetworkAclsAclResourceResult(dict):
    def __init__(__self__, *,
                 resource_id: str,
                 resource_type: str,
                 status: str):
        """
        :param str resource_id: The ID of the associated resource.
        :param str resource_type: The type of the associated resource.
        :param str status: The state of the network ACL.
        """
        pulumi.set(__self__, "resource_id", resource_id)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> str:
        """
        The ID of the associated resource.
        """
        return pulumi.get(self, "resource_id")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        The type of the associated resource.
        """
        return pulumi.get(self, "resource_type")

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


@pulumi.output_type
class GetNetworksVpcResult(dict):
    def __init__(__self__, *,
                 cidr_block: str,
                 creation_time: str,
                 description: str,
                 id: str,
                 ipv6_cidr_block: str,
                 is_default: bool,
                 region_id: str,
                 resource_group_id: str,
                 route_table_id: str,
                 router_id: str,
                 secondary_cidr_blocks: Sequence[str],
                 status: str,
                 tags: Mapping[str, Any],
                 user_cidrs: Sequence[str],
                 vpc_id: str,
                 vpc_name: str,
                 vrouter_id: str,
                 vswitch_ids: Sequence[str]):
        """
        :param str cidr_block: Filter results by a specific CIDR block. For example: "172.16.0.0/12".
        :param str creation_time: Time of creation.
        :param str description: Description of the VPC
        :param str id: ID of the VPC.
        :param str ipv6_cidr_block: The IPv6 CIDR block of the VPC.
        :param bool is_default: Indicate whether the VPC is the default one in the specified region.
        :param str region_id: ID of the region where the VPC is located.
        :param str resource_group_id: The Id of resource group which VPC belongs.
        :param str route_table_id: Route table ID of the VRouter.
        :param str router_id: The ID of the VRouter.
        :param Sequence[str] secondary_cidr_blocks: A list of secondary IPv4 CIDR blocks of the VPC.
        :param str status: Filter results by a specific status. Valid value are `Pending` and `Available`.
        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
        :param Sequence[str] user_cidrs: A list of user CIDRs.
        :param str vpc_id: ID of the VPC.
        :param str vpc_name: The name of the VPC.
        :param str vrouter_id: ID of the VRouter.
        :param Sequence[str] vswitch_ids: List of VSwitch IDs in the specified VPC
        """
        pulumi.set(__self__, "cidr_block", cidr_block)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ipv6_cidr_block", ipv6_cidr_block)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "region_id", region_id)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "router_id", router_id)
        pulumi.set(__self__, "secondary_cidr_blocks", secondary_cidr_blocks)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "user_cidrs", user_cidrs)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vpc_name", vpc_name)
        pulumi.set(__self__, "vrouter_id", vrouter_id)
        pulumi.set(__self__, "vswitch_ids", vswitch_ids)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> str:
        """
        Filter results by a specific CIDR block. For example: "172.16.0.0/12".
        """
        return pulumi.get(self, "cidr_block")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Time of creation.
        """
        return pulumi.get(self, "creation_time")

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

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

    @property
    @pulumi.getter(name="ipv6CidrBlock")
    def ipv6_cidr_block(self) -> str:
        """
        The IPv6 CIDR block of the VPC.
        """
        return pulumi.get(self, "ipv6_cidr_block")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Indicate whether the VPC is the default one in the specified region.
        """
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter(name="regionId")
    def region_id(self) -> str:
        """
        ID of the region where the VPC is located.
        """
        return pulumi.get(self, "region_id")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which VPC belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        """
        Route table ID of the VRouter.
        """
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> str:
        """
        The ID of the VRouter.
        """
        return pulumi.get(self, "router_id")

    @property
    @pulumi.getter(name="secondaryCidrBlocks")
    def secondary_cidr_blocks(self) -> Sequence[str]:
        """
        A list of secondary IPv4 CIDR blocks of the VPC.
        """
        return pulumi.get(self, "secondary_cidr_blocks")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Filter results by a specific status. Valid value are `Pending` and `Available`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, Any]:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="userCidrs")
    def user_cidrs(self) -> Sequence[str]:
        """
        A list of user CIDRs.
        """
        return pulumi.get(self, "user_cidrs")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        ID of the VPC.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vpcName")
    def vpc_name(self) -> str:
        """
        The name of the VPC.
        """
        return pulumi.get(self, "vpc_name")

    @property
    @pulumi.getter(name="vrouterId")
    def vrouter_id(self) -> str:
        """
        ID of the VRouter.
        """
        return pulumi.get(self, "vrouter_id")

    @property
    @pulumi.getter(name="vswitchIds")
    def vswitch_ids(self) -> Sequence[str]:
        """
        List of VSwitch IDs in the specified VPC
        """
        return pulumi.get(self, "vswitch_ids")


@pulumi.output_type
class GetRouteEntriesEntryResult(dict):
    def __init__(__self__, *,
                 cidr_block: str,
                 instance_id: str,
                 next_hop_type: str,
                 route_table_id: str,
                 status: str,
                 type: str):
        """
        :param str cidr_block: The destination CIDR block of the route entry.
        :param str instance_id: The instance ID of the next hop.
        :param str next_hop_type: The type of the next hop.
        :param str route_table_id: The ID of the router table to which the route entry belongs.
        :param str status: The status of the route entry.
        :param str type: The type of the route entry.
        """
        pulumi.set(__self__, "cidr_block", cidr_block)
        pulumi.set(__self__, "instance_id", instance_id)
        pulumi.set(__self__, "next_hop_type", next_hop_type)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> str:
        """
        The destination CIDR block of the route entry.
        """
        return pulumi.get(self, "cidr_block")

    @property
    @pulumi.getter(name="instanceId")
    def instance_id(self) -> str:
        """
        The instance ID of the next hop.
        """
        return pulumi.get(self, "instance_id")

    @property
    @pulumi.getter(name="nextHopType")
    def next_hop_type(self) -> str:
        """
        The type of the next hop.
        """
        return pulumi.get(self, "next_hop_type")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        """
        The ID of the router table to which the route entry belongs.
        """
        return pulumi.get(self, "route_table_id")

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

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


@pulumi.output_type
class GetRouteTablesTableResult(dict):
    def __init__(__self__, *,
                 description: str,
                 id: str,
                 name: str,
                 resource_group_id: str,
                 route_table_id: str,
                 route_table_name: str,
                 route_table_type: str,
                 router_id: str,
                 router_type: str,
                 status: str,
                 tags: Mapping[str, Any],
                 vpc_id: str,
                 vswitch_ids: Sequence[str]):
        """
        :param str description: The description of the route table instance.
        :param str id: ID of the Route Table.
        :param str name: Name of the route table.
        :param str resource_group_id: The Id of resource group which route tables belongs.
        :param str route_table_id: The route table id.
        :param str route_table_name: The route table name.
        :param str route_table_type: The type of route table.
        :param str router_id: The router ID.
        :param str router_type: The route type of route table. Valid values: `VRouter` and `VBR`.
        :param str status: The status of resource. Valid values: `Available` and `Pending`.
        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
        :param str vpc_id: Vpc id of the route table.
        :param Sequence[str] vswitch_ids: A list of vswitch id.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "route_table_name", route_table_name)
        pulumi.set(__self__, "route_table_type", route_table_type)
        pulumi.set(__self__, "router_id", router_id)
        pulumi.set(__self__, "router_type", router_type)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_ids", vswitch_ids)

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

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

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the route table.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which route tables belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        """
        The route table id.
        """
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> str:
        """
        The route table name.
        """
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="routeTableType")
    def route_table_type(self) -> str:
        """
        The type of route table.
        """
        return pulumi.get(self, "route_table_type")

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> str:
        """
        The router ID.
        """
        return pulumi.get(self, "router_id")

    @property
    @pulumi.getter(name="routerType")
    def router_type(self) -> str:
        """
        The route type of route table. Valid values: `VRouter` and `VBR`.
        """
        return pulumi.get(self, "router_type")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of resource. Valid values: `Available` and `Pending`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, Any]:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        Vpc id of the route table.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchIds")
    def vswitch_ids(self) -> Sequence[str]:
        """
        A list of vswitch id.
        """
        return pulumi.get(self, "vswitch_ids")


@pulumi.output_type
class GetRouterInterfacesInterfaceResult(dict):
    def __init__(__self__, *,
                 access_point_id: str,
                 creation_time: str,
                 description: str,
                 health_check_source_ip: str,
                 health_check_target_ip: str,
                 id: str,
                 name: str,
                 opposite_interface_id: str,
                 opposite_interface_owner_id: str,
                 opposite_region_id: str,
                 opposite_router_id: str,
                 opposite_router_type: str,
                 role: str,
                 router_id: str,
                 router_type: str,
                 specification: str,
                 status: str,
                 vpc_id: str):
        """
        :param str access_point_id: ID of the access point used by the VBR.
        :param str creation_time: Router interface creation time.
        :param str description: Router interface description.
        :param str health_check_source_ip: Source IP address used to perform health check on the physical connection.
        :param str health_check_target_ip: Destination IP address used to perform health check on the physical connection.
        :param str id: Router interface ID.
        :param str name: Router interface name.
        :param str opposite_interface_id: ID of the peer router interface.
        :param str opposite_interface_owner_id: Account ID of the owner of the peer router interface.
        :param str opposite_region_id: Peer router region ID.
        :param str opposite_router_id: Peer router ID.
        :param str opposite_router_type: Router type in the peer region. Possible values: `VRouter` and `VBR`.
        :param str role: Role of the router interface. Valid values are `InitiatingSide` (connection initiator) and 
               `AcceptingSide` (connection receiver). The value of this parameter must be `InitiatingSide` if the `router_type` is set to `VBR`.
        :param str router_id: ID of the VRouter located in the local region.
        :param str router_type: Router type in the local region. Valid values are `VRouter` and `VBR` (physical connection).
        :param str specification: Specification of the link, such as `Small.1` (10Mb), `Middle.1` (100Mb), `Large.2` (2Gb), ...etc.
        :param str status: Expected status. Valid values are `Active`, `Inactive` and `Idle`.
        :param str vpc_id: ID of the VPC that owns the router in the local region.
        """
        pulumi.set(__self__, "access_point_id", access_point_id)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "health_check_source_ip", health_check_source_ip)
        pulumi.set(__self__, "health_check_target_ip", health_check_target_ip)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "opposite_interface_id", opposite_interface_id)
        pulumi.set(__self__, "opposite_interface_owner_id", opposite_interface_owner_id)
        pulumi.set(__self__, "opposite_region_id", opposite_region_id)
        pulumi.set(__self__, "opposite_router_id", opposite_router_id)
        pulumi.set(__self__, "opposite_router_type", opposite_router_type)
        pulumi.set(__self__, "role", role)
        pulumi.set(__self__, "router_id", router_id)
        pulumi.set(__self__, "router_type", router_type)
        pulumi.set(__self__, "specification", specification)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="accessPointId")
    def access_point_id(self) -> str:
        """
        ID of the access point used by the VBR.
        """
        return pulumi.get(self, "access_point_id")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Router interface creation time.
        """
        return pulumi.get(self, "creation_time")

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

    @property
    @pulumi.getter(name="healthCheckSourceIp")
    def health_check_source_ip(self) -> str:
        """
        Source IP address used to perform health check on the physical connection.
        """
        return pulumi.get(self, "health_check_source_ip")

    @property
    @pulumi.getter(name="healthCheckTargetIp")
    def health_check_target_ip(self) -> str:
        """
        Destination IP address used to perform health check on the physical connection.
        """
        return pulumi.get(self, "health_check_target_ip")

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

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

    @property
    @pulumi.getter(name="oppositeInterfaceId")
    def opposite_interface_id(self) -> str:
        """
        ID of the peer router interface.
        """
        return pulumi.get(self, "opposite_interface_id")

    @property
    @pulumi.getter(name="oppositeInterfaceOwnerId")
    def opposite_interface_owner_id(self) -> str:
        """
        Account ID of the owner of the peer router interface.
        """
        return pulumi.get(self, "opposite_interface_owner_id")

    @property
    @pulumi.getter(name="oppositeRegionId")
    def opposite_region_id(self) -> str:
        """
        Peer router region ID.
        """
        return pulumi.get(self, "opposite_region_id")

    @property
    @pulumi.getter(name="oppositeRouterId")
    def opposite_router_id(self) -> str:
        """
        Peer router ID.
        """
        return pulumi.get(self, "opposite_router_id")

    @property
    @pulumi.getter(name="oppositeRouterType")
    def opposite_router_type(self) -> str:
        """
        Router type in the peer region. Possible values: `VRouter` and `VBR`.
        """
        return pulumi.get(self, "opposite_router_type")

    @property
    @pulumi.getter
    def role(self) -> str:
        """
        Role of the router interface. Valid values are `InitiatingSide` (connection initiator) and 
        `AcceptingSide` (connection receiver). The value of this parameter must be `InitiatingSide` if the `router_type` is set to `VBR`.
        """
        return pulumi.get(self, "role")

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> str:
        """
        ID of the VRouter located in the local region.
        """
        return pulumi.get(self, "router_id")

    @property
    @pulumi.getter(name="routerType")
    def router_type(self) -> str:
        """
        Router type in the local region. Valid values are `VRouter` and `VBR` (physical connection).
        """
        return pulumi.get(self, "router_type")

    @property
    @pulumi.getter
    def specification(self) -> str:
        """
        Specification of the link, such as `Small.1` (10Mb), `Middle.1` (100Mb), `Large.2` (2Gb), ...etc.
        """
        return pulumi.get(self, "specification")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Expected status. Valid values are `Active`, `Inactive` and `Idle`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        ID of the VPC that owns the router in the local region.
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class GetSnatEntriesEntryResult(dict):
    def __init__(__self__, *,
                 id: str,
                 snat_entry_id: str,
                 snat_entry_name: str,
                 snat_ip: str,
                 source_cidr: str,
                 source_vswitch_id: str,
                 status: str):
        """
        :param str id: The ID of the Snat Entry.
        :param str snat_entry_id: The ID of snat entry.
        :param str snat_entry_name: The name of snat entry.
        :param str snat_ip: The public IP of the Snat Entry.
        :param str source_cidr: The source CIDR block of the Snat Entry.
        :param str source_vswitch_id: The source vswitch ID.
        :param str status: The status of the Snat Entry. Valid values: `Available`, `Deleting` and `Pending`.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "snat_entry_id", snat_entry_id)
        pulumi.set(__self__, "snat_entry_name", snat_entry_name)
        pulumi.set(__self__, "snat_ip", snat_ip)
        pulumi.set(__self__, "source_cidr", source_cidr)
        pulumi.set(__self__, "source_vswitch_id", source_vswitch_id)
        pulumi.set(__self__, "status", status)

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

    @property
    @pulumi.getter(name="snatEntryId")
    def snat_entry_id(self) -> str:
        """
        The ID of snat entry.
        """
        return pulumi.get(self, "snat_entry_id")

    @property
    @pulumi.getter(name="snatEntryName")
    def snat_entry_name(self) -> str:
        """
        The name of snat entry.
        """
        return pulumi.get(self, "snat_entry_name")

    @property
    @pulumi.getter(name="snatIp")
    def snat_ip(self) -> str:
        """
        The public IP of the Snat Entry.
        """
        return pulumi.get(self, "snat_ip")

    @property
    @pulumi.getter(name="sourceCidr")
    def source_cidr(self) -> str:
        """
        The source CIDR block of the Snat Entry.
        """
        return pulumi.get(self, "source_cidr")

    @property
    @pulumi.getter(name="sourceVswitchId")
    def source_vswitch_id(self) -> str:
        """
        The source vswitch ID.
        """
        return pulumi.get(self, "source_vswitch_id")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the Snat Entry. Valid values: `Available`, `Deleting` and `Pending`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetSslVpnClientCertsCertResult(dict):
    def __init__(__self__, *,
                 create_time: str,
                 end_time: int,
                 id: str,
                 name: str,
                 ssl_vpn_server_id: str,
                 status: str):
        """
        :param str create_time: The time of creation.
        :param int end_time: The expiration time of the client certificate.
        :param str id: ID of the SSL-VPN client certificate.
        :param str name: The name of the SSL-VPN client certificate.
        :param str ssl_vpn_server_id: Use the SSL-VPN server ID as the search key.
        :param str status: The status of the client certificate. valid value:expiring-soon, normal, expired.
        """
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "end_time", end_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "ssl_vpn_server_id", ssl_vpn_server_id)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The time of creation.
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> int:
        """
        The expiration time of the client certificate.
        """
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        ID of the SSL-VPN client certificate.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="sslVpnServerId")
    def ssl_vpn_server_id(self) -> str:
        """
        Use the SSL-VPN server ID as the search key.
        """
        return pulumi.get(self, "ssl_vpn_server_id")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the client certificate. valid value:expiring-soon, normal, expired.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetSslVpnServersServerResult(dict):
    def __init__(__self__, *,
                 cipher: str,
                 client_ip_pool: str,
                 compress: bool,
                 connections: int,
                 create_time: str,
                 id: str,
                 internet_ip: str,
                 local_subnet: str,
                 max_connections: int,
                 name: str,
                 port: int,
                 proto: str,
                 vpn_gateway_id: str):
        """
        :param str cipher: The encryption algorithm used.
        :param str client_ip_pool: The IP address pool of the client.
        :param bool compress: Whether to compress.
        :param int connections: The number of current connections.
        :param str create_time: The time of creation.
        :param str id: The ID of the SSL-VPN server.
        :param str internet_ip: The public IP.
        :param str local_subnet: The local subnet of the VPN connection.
        :param int max_connections: The maximum number of connections.
        :param str name: The name of the SSL-VPN server.
        :param int port: The port used by the SSL-VPN server.
        :param str proto: The protocol used by the SSL-VPN server.
        :param str vpn_gateway_id: Use the VPN gateway ID as the search key.
        """
        pulumi.set(__self__, "cipher", cipher)
        pulumi.set(__self__, "client_ip_pool", client_ip_pool)
        pulumi.set(__self__, "compress", compress)
        pulumi.set(__self__, "connections", connections)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internet_ip", internet_ip)
        pulumi.set(__self__, "local_subnet", local_subnet)
        pulumi.set(__self__, "max_connections", max_connections)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "proto", proto)
        pulumi.set(__self__, "vpn_gateway_id", vpn_gateway_id)

    @property
    @pulumi.getter
    def cipher(self) -> str:
        """
        The encryption algorithm used.
        """
        return pulumi.get(self, "cipher")

    @property
    @pulumi.getter(name="clientIpPool")
    def client_ip_pool(self) -> str:
        """
        The IP address pool of the client.
        """
        return pulumi.get(self, "client_ip_pool")

    @property
    @pulumi.getter
    def compress(self) -> bool:
        """
        Whether to compress.
        """
        return pulumi.get(self, "compress")

    @property
    @pulumi.getter
    def connections(self) -> int:
        """
        The number of current connections.
        """
        return pulumi.get(self, "connections")

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> str:
        """
        The time of creation.
        """
        return pulumi.get(self, "create_time")

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

    @property
    @pulumi.getter(name="internetIp")
    def internet_ip(self) -> str:
        """
        The public IP.
        """
        return pulumi.get(self, "internet_ip")

    @property
    @pulumi.getter(name="localSubnet")
    def local_subnet(self) -> str:
        """
        The local subnet of the VPN connection.
        """
        return pulumi.get(self, "local_subnet")

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> int:
        """
        The maximum number of connections.
        """
        return pulumi.get(self, "max_connections")

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

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port used by the SSL-VPN server.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def proto(self) -> str:
        """
        The protocol used by the SSL-VPN server.
        """
        return pulumi.get(self, "proto")

    @property
    @pulumi.getter(name="vpnGatewayId")
    def vpn_gateway_id(self) -> str:
        """
        Use the VPN gateway ID as the search key.
        """
        return pulumi.get(self, "vpn_gateway_id")


@pulumi.output_type
class GetSwitchesVswitchResult(dict):
    def __init__(__self__, *,
                 available_ip_address_count: int,
                 cidr_block: str,
                 creation_time: str,
                 description: str,
                 id: str,
                 is_default: bool,
                 name: str,
                 resource_group_id: str,
                 route_table_id: str,
                 status: str,
                 tags: Mapping[str, Any],
                 vpc_id: str,
                 vswitch_id: str,
                 vswitch_name: str,
                 zone_id: str):
        """
        :param int available_ip_address_count: The available ip address count of the VSwitch.
        :param str cidr_block: Filter results by a specific CIDR block. For example: "172.16.0.0/12".
        :param str creation_time: Time of creation.
        :param str description: Description of the VSwitch.
        :param str id: ID of the VSwitch.
        :param bool is_default: Indicate whether the VSwitch is created by the system.
        :param str name: Name of the VSwitch.
        :param str resource_group_id: The Id of resource group which VSWitch belongs.
        :param str route_table_id: The route table ID of the VSwitch.
        :param str status: The status of the VSwitch. Valid values: `Available` and `Pending`.
        :param Mapping[str, Any] tags: A mapping of tags to assign to the resource.
        :param str vpc_id: ID of the VPC that owns the VSwitch.
        :param str vswitch_id: ID of the VSwitch.
        :param str vswitch_name: The name of the VSwitch.
        :param str zone_id: The availability zone of the VSwitch.
        """
        pulumi.set(__self__, "available_ip_address_count", available_ip_address_count)
        pulumi.set(__self__, "cidr_block", cidr_block)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_id", vswitch_id)
        pulumi.set(__self__, "vswitch_name", vswitch_name)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter(name="availableIpAddressCount")
    def available_ip_address_count(self) -> int:
        """
        The available ip address count of the VSwitch.
        """
        return pulumi.get(self, "available_ip_address_count")

    @property
    @pulumi.getter(name="cidrBlock")
    def cidr_block(self) -> str:
        """
        Filter results by a specific CIDR block. For example: "172.16.0.0/12".
        """
        return pulumi.get(self, "cidr_block")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> str:
        """
        Time of creation.
        """
        return pulumi.get(self, "creation_time")

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

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

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        """
        Indicate whether the VSwitch is created by the system.
        """
        return pulumi.get(self, "is_default")

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

    @property
    @pulumi.getter(name="resourceGroupId")
    def resource_group_id(self) -> str:
        """
        The Id of resource group which VSWitch belongs.
        """
        return pulumi.get(self, "resource_group_id")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        """
        The route table ID of the VSwitch.
        """
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the VSwitch. Valid values: `Available` and `Pending`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, Any]:
        """
        A mapping of tags to assign to the resource.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        ID of the VPC that owns the VSwitch.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="vswitchId")
    def vswitch_id(self) -> str:
        """
        ID of the VSwitch.
        """
        return pulumi.get(self, "vswitch_id")

    @property
    @pulumi.getter(name="vswitchName")
    def vswitch_name(self) -> str:
        """
        The name of the VSwitch.
        """
        return pulumi.get(self, "vswitch_name")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> str:
        """
        The availability zone of the VSwitch.
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class GetTrafficMirrorFilterEgressRulesRuleResult(dict):
    def __init__(__self__, *,
                 destination_cidr_block: str,
                 destination_port_range: str,
                 id: str,
                 priority: int,
                 protocol: str,
                 rule_action: str,
                 source_cidr_block: str,
                 source_port_range: str,
                 status: str,
                 traffic_mirror_filter_id: str,
                 traffic_mirror_filter_rule_id: str):
        """
        :param str destination_cidr_block: The destination CIDR block of the outbound traffic.
        :param str destination_port_range: The destination port range of the outbound traffic.
        :param str id: The ID of the Traffic Mirror Filter Egress Rule.
        :param int priority: The priority of the outbound rule. A smaller value indicates a higher priority. The maximum value is `10`, which indicates that you can configure at most 10 inbound rules for a filter.
        :param str protocol: The transport protocol used by outbound traffic that needs to be mirrored. Valid values: `ALL`, `ICMP`, `TCP`, `UDP`.
        :param str rule_action: The collection policy of the inbound rule. Valid values: `accept` or `drop`. `accept`: collects network traffic. `drop`: does not collect network traffic.
        :param str source_cidr_block: The source CIDR block of the outbound traffic.
        :param str source_port_range: The source port range of the outbound traffic.
        :param str status: The status of the resource. Valid values:`Creating`, `Created`, `Modifying` and `Deleting`.
        :param str traffic_mirror_filter_id: The ID of the filter associated with the outbound rule.
        :param str traffic_mirror_filter_rule_id: The first ID of the resource.
        """
        pulumi.set(__self__, "destination_cidr_block", destination_cidr_block)
        pulumi.set(__self__, "destination_port_range", destination_port_range)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "rule_action", rule_action)
        pulumi.set(__self__, "source_cidr_block", source_cidr_block)
        pulumi.set(__self__, "source_port_range", source_port_range)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "traffic_mirror_filter_id", traffic_mirror_filter_id)
        pulumi.set(__self__, "traffic_mirror_filter_rule_id", traffic_mirror_filter_rule_id)

    @property
    @pulumi.getter(name="destinationCidrBlock")
    def destination_cidr_block(self) -> str:
        """
        The destination CIDR block of the outbound traffic.
        """
        return pulumi.get(self, "destination_cidr_block")

    @property
    @pulumi.getter(name="destinationPortRange")
    def destination_port_range(self) -> str:
        """
        The destination port range of the outbound traffic.
        """
        return pulumi.get(self, "destination_port_range")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Traffic Mirror Filter Egress Rule.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        The priority of the outbound rule. A smaller value indicates a higher priority. The maximum value is `10`, which indicates that you can configure at most 10 inbound rules for a filter.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The transport protocol used by outbound traffic that needs to be mirrored. Valid values: `ALL`, `ICMP`, `TCP`, `UDP`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="ruleAction")
    def rule_action(self) -> str:
        """
        The collection policy of the inbound rule. Valid values: `accept` or `drop`. `accept`: collects network traffic. `drop`: does not collect network traffic.
        """
        return pulumi.get(self, "rule_action")

    @property
    @pulumi.getter(name="sourceCidrBlock")
    def source_cidr_block(self) -> str:
        """
        The source CIDR block of the outbound traffic.
        """
        return pulumi.get(self, "source_cidr_block")

    @property
    @pulumi.getter(name="sourcePortRange")
    def source_port_range(self) -> str:
        """
        The source port range of the outbound traffic.
        """
        return pulumi.get(self, "source_port_range")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the resource. Valid values:`Creating`, `Created`, `Modifying` and `Deleting`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="trafficMirrorFilterId")
    def traffic_mirror_filter_id(self) -> str:
        """
        The ID of the filter associated with the outbound rule.
        """
        return pulumi.get(self, "traffic_mirror_filter_id")

    @property
    @pulumi.getter(name="trafficMirrorFilterRuleId")
    def traffic_mirror_filter_rule_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "traffic_mirror_filter_rule_id")


@pulumi.output_type
class GetTrafficMirrorFilterIngressRulesRuleResult(dict):
    def __init__(__self__, *,
                 destination_cidr_block: str,
                 destination_port_range: str,
                 id: str,
                 priority: int,
                 protocol: str,
                 rule_action: str,
                 source_cidr_block: str,
                 source_port_range: str,
                 status: str,
                 traffic_mirror_filter_id: str,
                 traffic_mirror_filter_rule_id: str):
        """
        :param str destination_cidr_block: The destination CIDR block of the inbound traffic.
        :param str destination_port_range: The destination port range of the inbound traffic.
        :param str id: The ID of the Traffic Mirror Filter Egress Rule.
        :param int priority: The priority of the inbound rule. A smaller value indicates a higher priority. The maximum value is `10`, which indicates that you can configure at most 10 inbound rules for a filter.
        :param str protocol: The transport protocol used by inbound traffic that needs to be mirrored. Valid values: `ALL`, `ICMP`, `TCP`, `UDP`.
        :param str rule_action: The collection policy of the inbound rule. Valid values: `accept` or `drop`. `accept`: collects network traffic. `drop`: does not collect network traffic.
        :param str source_cidr_block: The source CIDR block of the inbound traffic.
        :param str source_port_range: The source port range of the inbound traffic.
        :param str status: The status of the resource. Valid values:`Creating`, `Created`, `Modifying` and `Deleting`.
        :param str traffic_mirror_filter_id: The ID of the filter associated with the inbound rule.
        :param str traffic_mirror_filter_rule_id: The first ID of the resource.
        """
        pulumi.set(__self__, "destination_cidr_block", destination_cidr_block)
        pulumi.set(__self__, "destination_port_range", destination_port_range)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "rule_action", rule_action)
        pulumi.set(__self__, "source_cidr_block", source_cidr_block)
        pulumi.set(__self__, "source_port_range", source_port_range)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "traffic_mirror_filter_id", traffic_mirror_filter_id)
        pulumi.set(__self__, "traffic_mirror_filter_rule_id", traffic_mirror_filter_rule_id)

    @property
    @pulumi.getter(name="destinationCidrBlock")
    def destination_cidr_block(self) -> str:
        """
        The destination CIDR block of the inbound traffic.
        """
        return pulumi.get(self, "destination_cidr_block")

    @property
    @pulumi.getter(name="destinationPortRange")
    def destination_port_range(self) -> str:
        """
        The destination port range of the inbound traffic.
        """
        return pulumi.get(self, "destination_port_range")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Traffic Mirror Filter Egress Rule.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        The priority of the inbound rule. A smaller value indicates a higher priority. The maximum value is `10`, which indicates that you can configure at most 10 inbound rules for a filter.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The transport protocol used by inbound traffic that needs to be mirrored. Valid values: `ALL`, `ICMP`, `TCP`, `UDP`.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="ruleAction")
    def rule_action(self) -> str:
        """
        The collection policy of the inbound rule. Valid values: `accept` or `drop`. `accept`: collects network traffic. `drop`: does not collect network traffic.
        """
        return pulumi.get(self, "rule_action")

    @property
    @pulumi.getter(name="sourceCidrBlock")
    def source_cidr_block(self) -> str:
        """
        The source CIDR block of the inbound traffic.
        """
        return pulumi.get(self, "source_cidr_block")

    @property
    @pulumi.getter(name="sourcePortRange")
    def source_port_range(self) -> str:
        """
        The source port range of the inbound traffic.
        """
        return pulumi.get(self, "source_port_range")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The status of the resource. Valid values:`Creating`, `Created`, `Modifying` and `Deleting`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="trafficMirrorFilterId")
    def traffic_mirror_filter_id(self) -> str:
        """
        The ID of the filter associated with the inbound rule.
        """
        return pulumi.get(self, "traffic_mirror_filter_id")

    @property
    @pulumi.getter(name="trafficMirrorFilterRuleId")
    def traffic_mirror_filter_rule_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "traffic_mirror_filter_rule_id")


@pulumi.output_type
class GetTrafficMirrorFiltersFilterResult(dict):
    def __init__(__self__, *,
                 id: str,
                 status: str,
                 traffic_mirror_filter_description: str,
                 traffic_mirror_filter_id: str,
                 traffic_mirror_filter_name: str):
        """
        :param str id: The ID of the Traffic Mirror Filter.
        :param str status: The state of the filter. Valid values:`Creating`, `Created`, `Modifying` and `Deleting`. `Creating`: The filter is being created. `Created`: The filter is created. `Modifying`: The filter is being modified. `Deleting`: The filter is being deleted.
        :param str traffic_mirror_filter_description: The description of the filter.
        :param str traffic_mirror_filter_id: The ID of the filter.
        :param str traffic_mirror_filter_name: The name of the filter.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "traffic_mirror_filter_description", traffic_mirror_filter_description)
        pulumi.set(__self__, "traffic_mirror_filter_id", traffic_mirror_filter_id)
        pulumi.set(__self__, "traffic_mirror_filter_name", traffic_mirror_filter_name)

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

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The state of the filter. Valid values:`Creating`, `Created`, `Modifying` and `Deleting`. `Creating`: The filter is being created. `Created`: The filter is created. `Modifying`: The filter is being modified. `Deleting`: The filter is being deleted.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="trafficMirrorFilterDescription")
    def traffic_mirror_filter_description(self) -> str:
        """
        The description of the filter.
        """
        return pulumi.get(self, "traffic_mirror_filter_description")

    @property
    @pulumi.getter(name="trafficMirrorFilterId")
    def traffic_mirror_filter_id(self) -> str:
        """
        The ID of the filter.
        """
        return pulumi.get(self, "traffic_mirror_filter_id")

    @property
    @pulumi.getter(name="trafficMirrorFilterName")
    def traffic_mirror_filter_name(self) -> str:
        """
        The name of the filter.
        """
        return pulumi.get(self, "traffic_mirror_filter_name")


@pulumi.output_type
class GetTrafficMirrorSessionsSessionResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 id: str,
                 packet_length: int,
                 priority: int,
                 status: str,
                 traffic_mirror_filter_id: str,
                 traffic_mirror_session_business_status: str,
                 traffic_mirror_session_description: str,
                 traffic_mirror_session_id: str,
                 traffic_mirror_session_name: str,
                 traffic_mirror_source_ids: Sequence[str],
                 traffic_mirror_target_id: str,
                 traffic_mirror_target_type: str,
                 virtual_network_id: int):
        """
        :param bool enabled: Indicates whether traffic mirror sessions are enabled. default to `false`.
        :param str id: The ID of the Traffic Mirror Session.
        :param int packet_length: The maximum transmission unit (MTU).
        :param int priority: The priority of the traffic mirror session. A smaller value indicates a higher priority.
        :param str status: The state of the traffic mirror session. Valid values: `Creating`, `Created`, `Modifying` and `Deleting`.
        :param str traffic_mirror_filter_id: The ID of the filter.
        :param str traffic_mirror_session_business_status: The state of the traffic mirror session. Valid values: `Normal` or `FinancialLocked`. `Normal`: working as expected. `FinancialLocked`: locked due to overdue payments.
        :param str traffic_mirror_session_description: The description of the traffic mirror session.
        :param str traffic_mirror_session_id: The first ID of the resource.
        :param str traffic_mirror_session_name: The name of the traffic mirror session.
        :param Sequence[str] traffic_mirror_source_ids: The ID of the mirror source.
        :param str traffic_mirror_target_id: The ID of the mirror destination. You can specify only an ENI or a Server Load Balancer (SLB) instance as a mirror destination.
        :param str traffic_mirror_target_type: The type of the mirror destination. Valid values: `NetworkInterface` or `SLB`. `NetworkInterface`: an ENI. `SLB`: an internal-facing SLB instance
        :param int virtual_network_id: You can specify VNIs to distinguish different mirrored traffic.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "packet_length", packet_length)
        pulumi.set(__self__, "priority", priority)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "traffic_mirror_filter_id", traffic_mirror_filter_id)
        pulumi.set(__self__, "traffic_mirror_session_business_status", traffic_mirror_session_business_status)
        pulumi.set(__self__, "traffic_mirror_session_description", traffic_mirror_session_description)
        pulumi.set(__self__, "traffic_mirror_session_id", traffic_mirror_session_id)
        pulumi.set(__self__, "traffic_mirror_session_name", traffic_mirror_session_name)
        pulumi.set(__self__, "traffic_mirror_source_ids", traffic_mirror_source_ids)
        pulumi.set(__self__, "traffic_mirror_target_id", traffic_mirror_target_id)
        pulumi.set(__self__, "traffic_mirror_target_type", traffic_mirror_target_type)
        pulumi.set(__self__, "virtual_network_id", virtual_network_id)

    @property
    @pulumi.getter
    def enabled(self) -> bool:
        """
        Indicates whether traffic mirror sessions are enabled. default to `false`.
        """
        return pulumi.get(self, "enabled")

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

    @property
    @pulumi.getter(name="packetLength")
    def packet_length(self) -> int:
        """
        The maximum transmission unit (MTU).
        """
        return pulumi.get(self, "packet_length")

    @property
    @pulumi.getter
    def priority(self) -> int:
        """
        The priority of the traffic mirror session. A smaller value indicates a higher priority.
        """
        return pulumi.get(self, "priority")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The state of the traffic mirror session. Valid values: `Creating`, `Created`, `Modifying` and `Deleting`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="trafficMirrorFilterId")
    def traffic_mirror_filter_id(self) -> str:
        """
        The ID of the filter.
        """
        return pulumi.get(self, "traffic_mirror_filter_id")

    @property
    @pulumi.getter(name="trafficMirrorSessionBusinessStatus")
    def traffic_mirror_session_business_status(self) -> str:
        """
        The state of the traffic mirror session. Valid values: `Normal` or `FinancialLocked`. `Normal`: working as expected. `FinancialLocked`: locked due to overdue payments.
        """
        return pulumi.get(self, "traffic_mirror_session_business_status")

    @property
    @pulumi.getter(name="trafficMirrorSessionDescription")
    def traffic_mirror_session_description(self) -> str:
        """
        The description of the traffic mirror session.
        """
        return pulumi.get(self, "traffic_mirror_session_description")

    @property
    @pulumi.getter(name="trafficMirrorSessionId")
    def traffic_mirror_session_id(self) -> str:
        """
        The first ID of the resource.
        """
        return pulumi.get(self, "traffic_mirror_session_id")

    @property
    @pulumi.getter(name="trafficMirrorSessionName")
    def traffic_mirror_session_name(self) -> str:
        """
        The name of the traffic mirror session.
        """
        return pulumi.get(self, "traffic_mirror_session_name")

    @property
    @pulumi.getter(name="trafficMirrorSourceIds")
    def traffic_mirror_source_ids(self) -> Sequence[str]:
        """
        The ID of the mirror source.
        """
        return pulumi.get(self, "traffic_mirror_source_ids")

    @property
    @pulumi.getter(name="trafficMirrorTargetId")
    def traffic_mirror_target_id(self) -> str:
        """
        The ID of the mirror destination. You can specify only an ENI or a Server Load Balancer (SLB) instance as a mirror destination.
        """
        return pulumi.get(self, "traffic_mirror_target_id")

    @property
    @pulumi.getter(name="trafficMirrorTargetType")
    def traffic_mirror_target_type(self) -> str:
        """
        The type of the mirror destination. Valid values: `NetworkInterface` or `SLB`. `NetworkInterface`: an ENI. `SLB`: an internal-facing SLB instance
        """
        return pulumi.get(self, "traffic_mirror_target_type")

    @property
    @pulumi.getter(name="virtualNetworkId")
    def virtual_network_id(self) -> int:
        """
        You can specify VNIs to distinguish different mirrored traffic.
        """
        return pulumi.get(self, "virtual_network_id")


@pulumi.output_type
class GetVpcFlowLogsLogResult(dict):
    def __init__(__self__, *,
                 description: str,
                 flow_log_id: str,
                 flow_log_name: str,
                 id: str,
                 log_store_name: str,
                 project_name: str,
                 resource_id: str,
                 resource_type: str,
                 status: str,
                 traffic_type: str):
        """
        :param str description: The Description of flow log.
        :param str flow_log_id: The flow log ID.
        :param str flow_log_name: The flow log name.
        :param str id: The ID of the Flow Log.
        :param str log_store_name: The log store name.
        :param str project_name: The project name.
        :param str resource_id: The resource id.
        :param str resource_type: The resource type.
        :param str status: The status of flow log.
        :param str traffic_type: The traffic type.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "flow_log_id", flow_log_id)
        pulumi.set(__self__, "flow_log_name", flow_log_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "log_store_name", log_store_name)
        pulumi.set(__self__, "project_name", project_name)
        pulumi.set(__self__, "resource_id", resource_id)
        pulumi.set(__self__, "resource_type", resource_type)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "traffic_type", traffic_type)

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

    @property
    @pulumi.getter(name="flowLogId")
    def flow_log_id(self) -> str:
        """
        The flow log ID.
        """
        return pulumi.get(self, "flow_log_id")

    @property
    @pulumi.getter(name="flowLogName")
    def flow_log_name(self) -> str:
        """
        The flow log name.
        """
        return pulumi.get(self, "flow_log_name")

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

    @property
    @pulumi.getter(name="logStoreName")
    def log_store_name(self) -> str:
        """
        The log store name.
        """
        return pulumi.get(self, "log_store_name")

    @property
    @pulumi.getter(name="projectName")
    def project_name(self) -> str:
        """
        The project name.
        """
        return pulumi.get(self, "project_name")

    @property
    @pulumi.getter(name="resourceId")
    def resource_id(self) -> str:
        """
        The resource id.
        """
        return pulumi.get(self, "resource_id")

    @property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> str:
        """
        The resource type.
        """
        return pulumi.get(self, "resource_type")

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

    @property
    @pulumi.getter(name="trafficType")
    def traffic_type(self) -> str:
        """
        The traffic type.
        """
        return pulumi.get(self, "traffic_type")


