# 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, Dict, List, Mapping, Optional, Tuple, Union
from .. import _utilities, _tables
from . import outputs

__all__ = [
    'NatGatewayBandwidthPackage',
    'NetworkAclAttachmentResource',
    'NetworkAclEntriesEgress',
    'NetworkAclEntriesIngress',
    'GetCommonBandwidthPackagesPackageResult',
    'GetCommonBandwidthPackagesPackagePublicIpAddressResult',
    'GetForwardEntriesEntryResult',
    'GetNatGatewaysGatewayResult',
    'GetNetworksVpcResult',
    'GetRouteEntriesEntryResult',
    'GetRouteTablesTableResult',
    'GetRouterInterfacesInterfaceResult',
    'GetSnatEntriesEntryResult',
    'GetSslVpnClientCertsCertResult',
    'GetSslVpnServersServerResult',
    'GetSwitchesVswitchResult',
]

@pulumi.output_type
class NatGatewayBandwidthPackage(dict):
    def __init__(__self__, *,
                 bandwidth: float,
                 ip_count: float,
                 public_ip_addresses: Optional[str] = None,
                 zone: Optional[str] = None):
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "ip_count", ip_count)
        if public_ip_addresses is not None:
            pulumi.set(__self__, "public_ip_addresses", public_ip_addresses)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

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

    @property
    @pulumi.getter(name="ipCount")
    def ip_count(self) -> float:
        return pulumi.get(self, "ip_count")

    @property
    @pulumi.getter(name="publicIpAddresses")
    def public_ip_addresses(self) -> Optional[str]:
        return pulumi.get(self, "public_ip_addresses")

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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


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

    def _translate_property(self, prop):
        return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop


@pulumi.output_type
class GetCommonBandwidthPackagesPackageResult(dict):
    def __init__(__self__, *,
                 bandwidth: str,
                 business_status: str,
                 creation_time: str,
                 description: str,
                 id: str,
                 isp: str,
                 name: str,
                 public_ip_addresses: List['outputs.GetCommonBandwidthPackagesPackagePublicIpAddressResult'],
                 status: str,
                 resource_group_id: Optional[str] = None):
        """
        :param str bandwidth: The peak bandwidth of the Internet Shared Bandwidth instance.
        :param str business_status: The business status of the Common Bandwidth Package instance.
        :param str creation_time: Time of creation.
        :param str description: The description of the Common Bandwidth Package instance.
        :param str id: ID of the Common Bandwidth Package.
        :param str isp: ISP of the Common Bandwidth Package.
        :param str name: Name of the Common Bandwidth Package.
        :param List['GetCommonBandwidthPackagesPackagePublicIpAddressArgs'] public_ip_addresses: Public ip addresses that in the Common Bandwidth Pakcage.
        :param str status: Status of the Common Bandwidth Package.
        :param str resource_group_id: The Id of resource group which the common bandwidth package belongs.
        """
        pulumi.set(__self__, "bandwidth", bandwidth)
        pulumi.set(__self__, "business_status", business_status)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "isp", isp)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "public_ip_addresses", public_ip_addresses)
        pulumi.set(__self__, "status", status)
        if resource_group_id is not None:
            pulumi.set(__self__, "resource_group_id", resource_group_id)

    @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="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="creationTime")
    def creation_time(self) -> str:
        """
        Time of creation.
        """
        return pulumi.get(self, "creation_time")

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

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

    @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="publicIpAddresses")
    def public_ip_addresses(self) -> List['outputs.GetCommonBandwidthPackagesPackagePublicIpAddressResult']:
        """
        Public ip addresses that in the Common Bandwidth Pakcage.
        """
        return pulumi.get(self, "public_ip_addresses")

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

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


@pulumi.output_type
class GetCommonBandwidthPackagesPackagePublicIpAddressResult(dict):
    def __init__(__self__, *,
                 allocation_id: str,
                 ip_address: str):
        pulumi.set(__self__, "allocation_id", allocation_id)
        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="ipAddress")
    def ip_address(self) -> str:
        return pulumi.get(self, "ip_address")


@pulumi.output_type
class GetForwardEntriesEntryResult(dict):
    def __init__(__self__, *,
                 external_ip: str,
                 external_port: 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 id: The ID of the Forward Entry.
        :param str internal_ip: The private IP address.
        :param str internal_port: The private port.
        :param str ip_protocol: The protocol type.
        :param str name: The forward entry name.
        :param str status: The status of the Forward Entry.
        """
        pulumi.set(__self__, "external_ip", external_ip)
        pulumi.set(__self__, "external_port", external_port)
        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
    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 private port.
        """
        return pulumi.get(self, "internal_port")

    @property
    @pulumi.getter(name="ipProtocol")
    def ip_protocol(self) -> str:
        """
        The protocol type.
        """
        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 the Forward Entry.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetNatGatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 creation_time: str,
                 description: str,
                 forward_table_id: str,
                 id: str,
                 ip_lists: List[str],
                 name: str,
                 snat_table_id: str,
                 spec: str,
                 status: str,
                 vpc_id: str):
        """
        :param str creation_time: Time of creation.
        :param str description: The description of the NAT gateway.
        :param str forward_table_id: The forward table id.
        :param str id: The ID of the NAT gateway.
        :param List[str] ip_lists: The ip address of the bind eip.
        :param str name: Name of the NAT gateway.
        :param str snat_table_id: The snat table id.
        :param str spec: The specification of the NAT gateway.
        :param str status: The status of the NAT gateway.
        :param str vpc_id: The ID of the VPC.
        """
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "forward_table_id", forward_table_id)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ip_lists", ip_lists)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "snat_table_id", snat_table_id)
        pulumi.set(__self__, "spec", spec)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @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:
        """
        The description of the NAT gateway.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="forwardTableId")
    def forward_table_id(self) -> str:
        """
        The forward table id.
        """
        return pulumi.get(self, "forward_table_id")

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

    @property
    @pulumi.getter(name="ipLists")
    def ip_lists(self) -> List[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="snatTableId")
    def snat_table_id(self) -> str:
        """
        The snat table id.
        """
        return pulumi.get(self, "snat_table_id")

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

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

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


@pulumi.output_type
class GetNetworksVpcResult(dict):
    def __init__(__self__, *,
                 cidr_block: str,
                 creation_time: str,
                 description: str,
                 id: str,
                 is_default: bool,
                 region_id: str,
                 route_table_id: str,
                 status: str,
                 tags: Mapping[str, Any],
                 vpc_name: str,
                 vrouter_id: str,
                 vswitch_ids: List[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 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 route_table_id: Route table ID of the VRouter.
        :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 str vpc_name: Name of the VPC.
        :param str vrouter_id: ID of the VRouter.
        :param List[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__, "is_default", is_default)
        pulumi.set(__self__, "region_id", region_id)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)
        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="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="routeTableId")
    def route_table_id(self) -> str:
        """
        Route table ID of the VRouter.
        """
        return pulumi.get(self, "route_table_id")

    @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="vpcName")
    def vpc_name(self) -> str:
        """
        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) -> List[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__, *,
                 creation_time: str,
                 description: str,
                 id: str,
                 name: str,
                 route_table_type: str,
                 router_id: str):
        """
        :param str creation_time: Time of creation.
        :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 route_table_type: The type of route table.
        :param str router_id: Router Id of the route table.
        """
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "route_table_type", route_table_type)
        pulumi.set(__self__, "router_id", router_id)

    @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:
        """
        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="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:
        """
        Router Id of the route table.
        """
        return pulumi.get(self, "router_id")


@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_ip: str,
                 source_cidr: str,
                 status: str):
        """
        :param str id: The ID of the 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 status: The status of the Snat Entry.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "snat_ip", snat_ip)
        pulumi.set(__self__, "source_cidr", source_cidr)
        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="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
    def status(self) -> str:
        """
        The status of the Snat Entry.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetSslVpnClientCertsCertResult(dict):
    def __init__(__self__, *,
                 create_time: str,
                 end_time: float,
                 id: str,
                 name: str,
                 ssl_vpn_server_id: str,
                 status: str):
        """
        :param str create_time: The time of creation.
        :param float 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) -> float:
        """
        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: float,
                 create_time: str,
                 id: str,
                 internet_ip: str,
                 local_subnet: str,
                 max_connections: float,
                 name: str,
                 port: float,
                 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 float 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 float max_connections: The maximum number of connections.
        :param str name: The name of the SSL-VPN server.
        :param float 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) -> float:
        """
        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) -> float:
        """
        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) -> float:
        """
        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__, *,
                 cidr_block: str,
                 creation_time: str,
                 description: str,
                 id: str,
                 instance_ids: List[str],
                 is_default: bool,
                 name: str,
                 vpc_id: str,
                 zone_id: 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 VSwitch.
        :param str id: ID of the VSwitch.
        :param List[str] instance_ids: List of ECS instance IDs in the specified VSwitch.
        :param bool is_default: Indicate whether the VSwitch is created by the system.
        :param str name: Name of the VSwitch.
        :param str vpc_id: ID of the VPC that owns the VSwitch.
        :param str zone_id: The availability zone of the VSwitch.
        """
        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__, "instance_ids", instance_ids)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "zone_id", zone_id)

    @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="instanceIds")
    def instance_ids(self) -> List[str]:
        """
        List of ECS instance IDs in the specified VSwitch.
        """
        return pulumi.get(self, "instance_ids")

    @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="vpcId")
    def vpc_id(self) -> str:
        """
        ID of the VPC that owns the VSwitch.
        """
        return pulumi.get(self, "vpc_id")

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


