# 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 copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities
from . import outputs

__all__ = [
    'ConnectionBgpConfig',
    'ConnectionHealthCheckConfig',
    'ConnectionIkeConfig',
    'ConnectionIpsecConfig',
    'ConnectionTunnelOptionsSpecification',
    'ConnectionTunnelOptionsSpecificationTunnelBgpConfig',
    'ConnectionTunnelOptionsSpecificationTunnelIkeConfig',
    'ConnectionTunnelOptionsSpecificationTunnelIpsecConfig',
    'GatewayVpnAttachmentBgpConfig',
    'GatewayVpnAttachmentHealthCheckConfig',
    'GatewayVpnAttachmentIkeConfig',
    'GatewayVpnAttachmentIpsecConfig',
    'IpsecServerIkeConfig',
    'IpsecServerIpsecConfig',
    'GetConnectionsConnectionResult',
    'GetConnectionsConnectionIkeConfigResult',
    'GetConnectionsConnectionIpsecConfigResult',
    'GetConnectionsConnectionTunnelOptionsSpecificationResult',
    'GetConnectionsConnectionTunnelOptionsSpecificationTunnelBgpConfigResult',
    'GetConnectionsConnectionTunnelOptionsSpecificationTunnelIkeConfigResult',
    'GetConnectionsConnectionTunnelOptionsSpecificationTunnelIpsecConfigResult',
    'GetConnectionsConnectionVcoHealthCheckResult',
    'GetConnectionsConnectionVpnBgpConfigResult',
    'GetCustomerGatewaysGatewayResult',
    'GetGatewayVcoRoutesRouteResult',
    'GetGatewayVpnAttachmentsAttachmentResult',
    'GetGatewayVpnAttachmentsAttachmentBgpConfigResult',
    'GetGatewayVpnAttachmentsAttachmentHealthCheckConfigResult',
    'GetGatewayVpnAttachmentsAttachmentIkeConfigResult',
    'GetGatewayVpnAttachmentsAttachmentIpsecConfigResult',
    'GetGatewayZonesZoneResult',
    'GetGatewaysGatewayResult',
]

@pulumi.output_type
class ConnectionBgpConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "localAsn":
            suggest = "local_asn"
        elif key == "localBgpIp":
            suggest = "local_bgp_ip"
        elif key == "tunnelCidr":
            suggest = "tunnel_cidr"

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

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

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

    def __init__(__self__, *,
                 enable: Optional[bool] = None,
                 local_asn: Optional[str] = None,
                 local_bgp_ip: Optional[str] = None,
                 status: Optional[str] = None,
                 tunnel_cidr: Optional[str] = None):
        """
        :param bool enable: specifies whether to enable BGP. Valid values: true and false (default).
        :param str local_asn: the autonomous system number (ASN) on the Alibaba Cloud side. 
               Valid values: 1 to 4294967295. Default value: 45104. You can enter a value in two segments separated by a period (.).
               Each segment is 16 bits in length. Enter the number in each segment in decimal format.
               For example, if you enter 123.456, the ASN is 8061384. The ASN is calculated by using the following formula: 123 × 65536 + 456 = 8061384.
        :param str local_bgp_ip: the BGP address on the Alibaba Cloud side. It must be an IP address that falls within the CIDR block of the IPsec tunnel.
        :param str status: The negotiation status of Tunnel.
        :param str tunnel_cidr: The CIDR block of the IPsec tunnel. The CIDR block must belong to 169.254.0.0/16 and the subnet mask is 30 bits in length.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if local_asn is not None:
            pulumi.set(__self__, "local_asn", local_asn)
        if local_bgp_ip is not None:
            pulumi.set(__self__, "local_bgp_ip", local_bgp_ip)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if tunnel_cidr is not None:
            pulumi.set(__self__, "tunnel_cidr", tunnel_cidr)

    @property
    @pulumi.getter
    def enable(self) -> Optional[bool]:
        """
        specifies whether to enable BGP. Valid values: true and false (default).
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="localAsn")
    def local_asn(self) -> Optional[str]:
        """
        the autonomous system number (ASN) on the Alibaba Cloud side. 
        Valid values: 1 to 4294967295. Default value: 45104. You can enter a value in two segments separated by a period (.).
        Each segment is 16 bits in length. Enter the number in each segment in decimal format.
        For example, if you enter 123.456, the ASN is 8061384. The ASN is calculated by using the following formula: 123 × 65536 + 456 = 8061384.
        """
        return pulumi.get(self, "local_asn")

    @property
    @pulumi.getter(name="localBgpIp")
    def local_bgp_ip(self) -> Optional[str]:
        """
        the BGP address on the Alibaba Cloud side. It must be an IP address that falls within the CIDR block of the IPsec tunnel.
        """
        return pulumi.get(self, "local_bgp_ip")

    @property
    @pulumi.getter
    def status(self) -> Optional[str]:
        """
        The negotiation status of Tunnel.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="tunnelCidr")
    def tunnel_cidr(self) -> Optional[str]:
        """
        The CIDR block of the IPsec tunnel. The CIDR block must belong to 169.254.0.0/16 and the subnet mask is 30 bits in length.
        """
        return pulumi.get(self, "tunnel_cidr")


@pulumi.output_type
class ConnectionHealthCheckConfig(dict):
    def __init__(__self__, *,
                 dip: Optional[str] = None,
                 enable: Optional[bool] = None,
                 interval: Optional[int] = None,
                 retry: Optional[int] = None,
                 sip: Optional[str] = None):
        """
        :param str dip: the destination IP address configured for health checks.
        :param bool enable: specifies whether to enable health checks. Valid values: true and false. Default value: false.
        :param int interval: the time interval of health check retries. Unit: seconds. Default value: 3.
        :param int retry: the maximum number of health check retries. Default value: 3.
        :param str sip: the source IP address that is used for health checks.
        """
        if dip is not None:
            pulumi.set(__self__, "dip", dip)
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if retry is not None:
            pulumi.set(__self__, "retry", retry)
        if sip is not None:
            pulumi.set(__self__, "sip", sip)

    @property
    @pulumi.getter
    def dip(self) -> Optional[str]:
        """
        the destination IP address configured for health checks.
        """
        return pulumi.get(self, "dip")

    @property
    @pulumi.getter
    def enable(self) -> Optional[bool]:
        """
        specifies whether to enable health checks. Valid values: true and false. Default value: false.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        the time interval of health check retries. Unit: seconds. Default value: 3.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def retry(self) -> Optional[int]:
        """
        the maximum number of health check retries. Default value: 3.
        """
        return pulumi.get(self, "retry")

    @property
    @pulumi.getter
    def sip(self) -> Optional[str]:
        """
        the source IP address that is used for health checks.
        """
        return pulumi.get(self, "sip")


@pulumi.output_type
class ConnectionIkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ikeAuthAlg":
            suggest = "ike_auth_alg"
        elif key == "ikeEncAlg":
            suggest = "ike_enc_alg"
        elif key == "ikeLifetime":
            suggest = "ike_lifetime"
        elif key == "ikeLocalId":
            suggest = "ike_local_id"
        elif key == "ikeMode":
            suggest = "ike_mode"
        elif key == "ikePfs":
            suggest = "ike_pfs"
        elif key == "ikeRemoteId":
            suggest = "ike_remote_id"
        elif key == "ikeVersion":
            suggest = "ike_version"

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

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

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

    def __init__(__self__, *,
                 ike_auth_alg: Optional[str] = None,
                 ike_enc_alg: Optional[str] = None,
                 ike_lifetime: Optional[int] = None,
                 ike_local_id: Optional[str] = None,
                 ike_mode: Optional[str] = None,
                 ike_pfs: Optional[str] = None,
                 ike_remote_id: Optional[str] = None,
                 ike_version: Optional[str] = None,
                 psk: Optional[str] = None):
        """
        :param str ike_auth_alg: the authentication algorithm that is used in Phase 1 negotiations. Valid values: md5, sha1, sha2
        :param str ike_enc_alg: the encryption algorithm that is used in Phase 1 negotiations. Valid values: aes, aes192, aes256, des, and 3des. Default value: aes.
        :param int ike_lifetime: the SA lifetime as a result of Phase 1 negotiations. Unit: seconds. Valid values: 0 to 86400. Default value: 86400.
        :param str ike_local_id: the identifier of the VPN gateway. It can contain at most 100 characters. The default value is the IP address of the VPN gateway.
        :param str ike_mode: the negotiation mode of IKE. Valid values: main and aggressive. Default value: main.
               - main: This mode offers higher security during negotiations.
               - aggressive: This mode supports faster negotiations and a higher success rate.
        :param str ike_pfs: the Diffie-Hellman key exchange algorithm that is used in Phase 1 negotiations. Valid values: group1, group2, group5, and group14. Default value: group2.
        :param str ike_remote_id: the identifier of the customer gateway. It can contain at most 100 characters. The default value is the IP address of the customer gateway.
        :param str ike_version: the version of the Internet Key Exchange (IKE) protocol. Valid values: ikev1 and ikev2. Default value: ikev1.
               Compared with IKEv1, IKEv2 simplifies the security association (SA) negotiation process and provides better support for scenarios with multiple CIDR blocks.
        :param str psk: the pre-shared key that is used for identity authentication between the VPN gateway and the on-premises data center. The key must be 1 to 100 characters in length and can contain digits, letters, and the following special characters: ~!\\`@#$%^&*()_-+={}[]|;:',.<>/? If you do not specify a pre-shared key, the system randomly generates a 16-bit string as the pre-shared key. You can call the DescribeVpnConnection operation to query the pre-shared key that is automatically generated by the system.
        """
        if ike_auth_alg is not None:
            pulumi.set(__self__, "ike_auth_alg", ike_auth_alg)
        if ike_enc_alg is not None:
            pulumi.set(__self__, "ike_enc_alg", ike_enc_alg)
        if ike_lifetime is not None:
            pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        if ike_local_id is not None:
            pulumi.set(__self__, "ike_local_id", ike_local_id)
        if ike_mode is not None:
            pulumi.set(__self__, "ike_mode", ike_mode)
        if ike_pfs is not None:
            pulumi.set(__self__, "ike_pfs", ike_pfs)
        if ike_remote_id is not None:
            pulumi.set(__self__, "ike_remote_id", ike_remote_id)
        if ike_version is not None:
            pulumi.set(__self__, "ike_version", ike_version)
        if psk is not None:
            pulumi.set(__self__, "psk", psk)

    @property
    @pulumi.getter(name="ikeAuthAlg")
    def ike_auth_alg(self) -> Optional[str]:
        """
        the authentication algorithm that is used in Phase 1 negotiations. Valid values: md5, sha1, sha2
        """
        return pulumi.get(self, "ike_auth_alg")

    @property
    @pulumi.getter(name="ikeEncAlg")
    def ike_enc_alg(self) -> Optional[str]:
        """
        the encryption algorithm that is used in Phase 1 negotiations. Valid values: aes, aes192, aes256, des, and 3des. Default value: aes.
        """
        return pulumi.get(self, "ike_enc_alg")

    @property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> Optional[int]:
        """
        the SA lifetime as a result of Phase 1 negotiations. Unit: seconds. Valid values: 0 to 86400. Default value: 86400.
        """
        return pulumi.get(self, "ike_lifetime")

    @property
    @pulumi.getter(name="ikeLocalId")
    def ike_local_id(self) -> Optional[str]:
        """
        the identifier of the VPN gateway. It can contain at most 100 characters. The default value is the IP address of the VPN gateway.
        """
        return pulumi.get(self, "ike_local_id")

    @property
    @pulumi.getter(name="ikeMode")
    def ike_mode(self) -> Optional[str]:
        """
        the negotiation mode of IKE. Valid values: main and aggressive. Default value: main.
        - main: This mode offers higher security during negotiations.
        - aggressive: This mode supports faster negotiations and a higher success rate.
        """
        return pulumi.get(self, "ike_mode")

    @property
    @pulumi.getter(name="ikePfs")
    def ike_pfs(self) -> Optional[str]:
        """
        the Diffie-Hellman key exchange algorithm that is used in Phase 1 negotiations. Valid values: group1, group2, group5, and group14. Default value: group2.
        """
        return pulumi.get(self, "ike_pfs")

    @property
    @pulumi.getter(name="ikeRemoteId")
    def ike_remote_id(self) -> Optional[str]:
        """
        the identifier of the customer gateway. It can contain at most 100 characters. The default value is the IP address of the customer gateway.
        """
        return pulumi.get(self, "ike_remote_id")

    @property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> Optional[str]:
        """
        the version of the Internet Key Exchange (IKE) protocol. Valid values: ikev1 and ikev2. Default value: ikev1.
        Compared with IKEv1, IKEv2 simplifies the security association (SA) negotiation process and provides better support for scenarios with multiple CIDR blocks.
        """
        return pulumi.get(self, "ike_version")

    @property
    @pulumi.getter
    def psk(self) -> Optional[str]:
        """
        the pre-shared key that is used for identity authentication between the VPN gateway and the on-premises data center. The key must be 1 to 100 characters in length and can contain digits, letters, and the following special characters: ~!\\`@#$%^&*()_-+={}[]|;:',.<>/? If you do not specify a pre-shared key, the system randomly generates a 16-bit string as the pre-shared key. You can call the DescribeVpnConnection operation to query the pre-shared key that is automatically generated by the system.
        """
        return pulumi.get(self, "psk")


@pulumi.output_type
class ConnectionIpsecConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipsecAuthAlg":
            suggest = "ipsec_auth_alg"
        elif key == "ipsecEncAlg":
            suggest = "ipsec_enc_alg"
        elif key == "ipsecLifetime":
            suggest = "ipsec_lifetime"
        elif key == "ipsecPfs":
            suggest = "ipsec_pfs"

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

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

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

    def __init__(__self__, *,
                 ipsec_auth_alg: Optional[str] = None,
                 ipsec_enc_alg: Optional[str] = None,
                 ipsec_lifetime: Optional[int] = None,
                 ipsec_pfs: Optional[str] = None):
        """
        :param str ipsec_auth_alg: the authentication algorithm that is used in Phase 2 negotiations. Valid values: md5, sha1, sha256, sha384, and sha512. Default value: md5.
        :param str ipsec_enc_alg: the encryption algorithm that is used in Phase 2 negotiations. Valid values: aes, aes192, aes256, des, and 3des. Default value: aes.
        :param int ipsec_lifetime: the SA lifetime that is determined by Phase 2 negotiations. Unit: seconds. Valid values: 0 to 86400. Default value: 86400.
        :param str ipsec_pfs: the DH key exchange algorithm that is used in Phase 2 negotiations. Valid values: disabled, group1, group2, group5, and group14. Default value: group2.
        """
        if ipsec_auth_alg is not None:
            pulumi.set(__self__, "ipsec_auth_alg", ipsec_auth_alg)
        if ipsec_enc_alg is not None:
            pulumi.set(__self__, "ipsec_enc_alg", ipsec_enc_alg)
        if ipsec_lifetime is not None:
            pulumi.set(__self__, "ipsec_lifetime", ipsec_lifetime)
        if ipsec_pfs is not None:
            pulumi.set(__self__, "ipsec_pfs", ipsec_pfs)

    @property
    @pulumi.getter(name="ipsecAuthAlg")
    def ipsec_auth_alg(self) -> Optional[str]:
        """
        the authentication algorithm that is used in Phase 2 negotiations. Valid values: md5, sha1, sha256, sha384, and sha512. Default value: md5.
        """
        return pulumi.get(self, "ipsec_auth_alg")

    @property
    @pulumi.getter(name="ipsecEncAlg")
    def ipsec_enc_alg(self) -> Optional[str]:
        """
        the encryption algorithm that is used in Phase 2 negotiations. Valid values: aes, aes192, aes256, des, and 3des. Default value: aes.
        """
        return pulumi.get(self, "ipsec_enc_alg")

    @property
    @pulumi.getter(name="ipsecLifetime")
    def ipsec_lifetime(self) -> Optional[int]:
        """
        the SA lifetime that is determined by Phase 2 negotiations. Unit: seconds. Valid values: 0 to 86400. Default value: 86400.
        """
        return pulumi.get(self, "ipsec_lifetime")

    @property
    @pulumi.getter(name="ipsecPfs")
    def ipsec_pfs(self) -> Optional[str]:
        """
        the DH key exchange algorithm that is used in Phase 2 negotiations. Valid values: disabled, group1, group2, group5, and group14. Default value: group2.
        """
        return pulumi.get(self, "ipsec_pfs")


@pulumi.output_type
class ConnectionTunnelOptionsSpecification(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customerGatewayId":
            suggest = "customer_gateway_id"
        elif key == "enableDpd":
            suggest = "enable_dpd"
        elif key == "enableNatTraversal":
            suggest = "enable_nat_traversal"
        elif key == "internetIp":
            suggest = "internet_ip"
        elif key == "tunnelBgpConfig":
            suggest = "tunnel_bgp_config"
        elif key == "tunnelId":
            suggest = "tunnel_id"
        elif key == "tunnelIkeConfig":
            suggest = "tunnel_ike_config"
        elif key == "tunnelIpsecConfig":
            suggest = "tunnel_ipsec_config"
        elif key == "zoneNo":
            suggest = "zone_no"

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

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

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

    def __init__(__self__, *,
                 customer_gateway_id: Optional[str] = None,
                 enable_dpd: Optional[bool] = None,
                 enable_nat_traversal: Optional[bool] = None,
                 internet_ip: Optional[str] = None,
                 role: Optional[str] = None,
                 state: Optional[str] = None,
                 status: Optional[str] = None,
                 tunnel_bgp_config: Optional['outputs.ConnectionTunnelOptionsSpecificationTunnelBgpConfig'] = None,
                 tunnel_id: Optional[str] = None,
                 tunnel_ike_config: Optional['outputs.ConnectionTunnelOptionsSpecificationTunnelIkeConfig'] = None,
                 tunnel_ipsec_config: Optional['outputs.ConnectionTunnelOptionsSpecificationTunnelIpsecConfig'] = None,
                 zone_no: Optional[str] = None):
        """
        :param str customer_gateway_id: The ID of the customer gateway in Tunnel.
        :param bool enable_dpd: Wether enable Dpd detection.
        :param bool enable_nat_traversal: enable nat traversal.
        :param str internet_ip: The local internet IP in Tunnel.
        :param str role: The role of Tunnel.
        :param str state: The state of Tunnel.
        :param str status: The negotiation status of Tunnel.
        :param 'ConnectionTunnelOptionsSpecificationTunnelBgpConfigArgs' tunnel_bgp_config: The bgp config of Tunnel. See `tunnel_bgp_config` below.
        :param str tunnel_id: The tunnel ID of IPsec-VPN connection.
        :param 'ConnectionTunnelOptionsSpecificationTunnelIkeConfigArgs' tunnel_ike_config: The configuration of Phase 1 negotiations in Tunnel. See `tunnel_ike_config` below.
        :param 'ConnectionTunnelOptionsSpecificationTunnelIpsecConfigArgs' tunnel_ipsec_config: IPsec configuration in Tunnel. See `tunnel_ipsec_config` below.
        :param str zone_no: The zoneNo of tunnel.
        """
        if customer_gateway_id is not None:
            pulumi.set(__self__, "customer_gateway_id", customer_gateway_id)
        if enable_dpd is not None:
            pulumi.set(__self__, "enable_dpd", enable_dpd)
        if enable_nat_traversal is not None:
            pulumi.set(__self__, "enable_nat_traversal", enable_nat_traversal)
        if internet_ip is not None:
            pulumi.set(__self__, "internet_ip", internet_ip)
        if role is not None:
            pulumi.set(__self__, "role", role)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if tunnel_bgp_config is not None:
            pulumi.set(__self__, "tunnel_bgp_config", tunnel_bgp_config)
        if tunnel_id is not None:
            pulumi.set(__self__, "tunnel_id", tunnel_id)
        if tunnel_ike_config is not None:
            pulumi.set(__self__, "tunnel_ike_config", tunnel_ike_config)
        if tunnel_ipsec_config is not None:
            pulumi.set(__self__, "tunnel_ipsec_config", tunnel_ipsec_config)
        if zone_no is not None:
            pulumi.set(__self__, "zone_no", zone_no)

    @property
    @pulumi.getter(name="customerGatewayId")
    def customer_gateway_id(self) -> Optional[str]:
        """
        The ID of the customer gateway in Tunnel.
        """
        return pulumi.get(self, "customer_gateway_id")

    @property
    @pulumi.getter(name="enableDpd")
    def enable_dpd(self) -> Optional[bool]:
        """
        Wether enable Dpd detection.
        """
        return pulumi.get(self, "enable_dpd")

    @property
    @pulumi.getter(name="enableNatTraversal")
    def enable_nat_traversal(self) -> Optional[bool]:
        """
        enable nat traversal.
        """
        return pulumi.get(self, "enable_nat_traversal")

    @property
    @pulumi.getter(name="internetIp")
    def internet_ip(self) -> Optional[str]:
        """
        The local internet IP in Tunnel.
        """
        return pulumi.get(self, "internet_ip")

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

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

    @property
    @pulumi.getter
    def status(self) -> Optional[str]:
        """
        The negotiation status of Tunnel.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="tunnelBgpConfig")
    def tunnel_bgp_config(self) -> Optional['outputs.ConnectionTunnelOptionsSpecificationTunnelBgpConfig']:
        """
        The bgp config of Tunnel. See `tunnel_bgp_config` below.
        """
        return pulumi.get(self, "tunnel_bgp_config")

    @property
    @pulumi.getter(name="tunnelId")
    def tunnel_id(self) -> Optional[str]:
        """
        The tunnel ID of IPsec-VPN connection.
        """
        return pulumi.get(self, "tunnel_id")

    @property
    @pulumi.getter(name="tunnelIkeConfig")
    def tunnel_ike_config(self) -> Optional['outputs.ConnectionTunnelOptionsSpecificationTunnelIkeConfig']:
        """
        The configuration of Phase 1 negotiations in Tunnel. See `tunnel_ike_config` below.
        """
        return pulumi.get(self, "tunnel_ike_config")

    @property
    @pulumi.getter(name="tunnelIpsecConfig")
    def tunnel_ipsec_config(self) -> Optional['outputs.ConnectionTunnelOptionsSpecificationTunnelIpsecConfig']:
        """
        IPsec configuration in Tunnel. See `tunnel_ipsec_config` below.
        """
        return pulumi.get(self, "tunnel_ipsec_config")

    @property
    @pulumi.getter(name="zoneNo")
    def zone_no(self) -> Optional[str]:
        """
        The zoneNo of tunnel.
        """
        return pulumi.get(self, "zone_no")


@pulumi.output_type
class ConnectionTunnelOptionsSpecificationTunnelBgpConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bgpStatus":
            suggest = "bgp_status"
        elif key == "localAsn":
            suggest = "local_asn"
        elif key == "localBgpIp":
            suggest = "local_bgp_ip"
        elif key == "peerAsn":
            suggest = "peer_asn"
        elif key == "peerBgpIp":
            suggest = "peer_bgp_ip"
        elif key == "tunnelCidr":
            suggest = "tunnel_cidr"

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

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

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

    def __init__(__self__, *,
                 bgp_status: Optional[str] = None,
                 local_asn: Optional[str] = None,
                 local_bgp_ip: Optional[str] = None,
                 peer_asn: Optional[str] = None,
                 peer_bgp_ip: Optional[str] = None,
                 tunnel_cidr: Optional[str] = None):
        """
        :param str bgp_status: Whether BGP function is turned on.
        :param str peer_asn: Peer asn.
        :param str peer_bgp_ip: Peer bgp ip.
        """
        if bgp_status is not None:
            pulumi.set(__self__, "bgp_status", bgp_status)
        if local_asn is not None:
            pulumi.set(__self__, "local_asn", local_asn)
        if local_bgp_ip is not None:
            pulumi.set(__self__, "local_bgp_ip", local_bgp_ip)
        if peer_asn is not None:
            pulumi.set(__self__, "peer_asn", peer_asn)
        if peer_bgp_ip is not None:
            pulumi.set(__self__, "peer_bgp_ip", peer_bgp_ip)
        if tunnel_cidr is not None:
            pulumi.set(__self__, "tunnel_cidr", tunnel_cidr)

    @property
    @pulumi.getter(name="bgpStatus")
    def bgp_status(self) -> Optional[str]:
        """
        Whether BGP function is turned on.
        """
        return pulumi.get(self, "bgp_status")

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

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

    @property
    @pulumi.getter(name="peerAsn")
    def peer_asn(self) -> Optional[str]:
        """
        Peer asn.
        """
        return pulumi.get(self, "peer_asn")

    @property
    @pulumi.getter(name="peerBgpIp")
    def peer_bgp_ip(self) -> Optional[str]:
        """
        Peer bgp ip.
        """
        return pulumi.get(self, "peer_bgp_ip")

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


@pulumi.output_type
class ConnectionTunnelOptionsSpecificationTunnelIkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ikeAuthAlg":
            suggest = "ike_auth_alg"
        elif key == "ikeEncAlg":
            suggest = "ike_enc_alg"
        elif key == "ikeLifetime":
            suggest = "ike_lifetime"
        elif key == "ikeMode":
            suggest = "ike_mode"
        elif key == "ikePfs":
            suggest = "ike_pfs"
        elif key == "ikeVersion":
            suggest = "ike_version"
        elif key == "localId":
            suggest = "local_id"
        elif key == "remoteId":
            suggest = "remote_id"

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

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

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

    def __init__(__self__, *,
                 ike_auth_alg: Optional[str] = None,
                 ike_enc_alg: Optional[str] = None,
                 ike_lifetime: Optional[int] = None,
                 ike_mode: Optional[str] = None,
                 ike_pfs: Optional[str] = None,
                 ike_version: Optional[str] = None,
                 local_id: Optional[str] = None,
                 psk: Optional[str] = None,
                 remote_id: Optional[str] = None):
        """
        :param str local_id: The identifier of the tunnel on the Alibaba Cloud side, which is used in Phase 1 negotiations. It can contain at most 100 characters. The default value is the IP address of the tunnel.
               LocalId supports fully qualified domain names (FQDNs). If you use an FQDN, we recommend that you set the negotiation mode to aggressive.
        :param str remote_id: The identifier of the tunnel peer, which is used in Phase 1 negotiations. It can contain at most 100 characters. The default value is the IP address of the customer gateway that is associated with the tunnel.
               RemoteId supports FQDNs. If you use an FQDN, we recommend that you set the negotiation mode to aggressive.
        """
        if ike_auth_alg is not None:
            pulumi.set(__self__, "ike_auth_alg", ike_auth_alg)
        if ike_enc_alg is not None:
            pulumi.set(__self__, "ike_enc_alg", ike_enc_alg)
        if ike_lifetime is not None:
            pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        if ike_mode is not None:
            pulumi.set(__self__, "ike_mode", ike_mode)
        if ike_pfs is not None:
            pulumi.set(__self__, "ike_pfs", ike_pfs)
        if ike_version is not None:
            pulumi.set(__self__, "ike_version", ike_version)
        if local_id is not None:
            pulumi.set(__self__, "local_id", local_id)
        if psk is not None:
            pulumi.set(__self__, "psk", psk)
        if remote_id is not None:
            pulumi.set(__self__, "remote_id", remote_id)

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

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

    @property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> Optional[int]:
        return pulumi.get(self, "ike_lifetime")

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

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

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

    @property
    @pulumi.getter(name="localId")
    def local_id(self) -> Optional[str]:
        """
        The identifier of the tunnel on the Alibaba Cloud side, which is used in Phase 1 negotiations. It can contain at most 100 characters. The default value is the IP address of the tunnel.
        LocalId supports fully qualified domain names (FQDNs). If you use an FQDN, we recommend that you set the negotiation mode to aggressive.
        """
        return pulumi.get(self, "local_id")

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

    @property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> Optional[str]:
        """
        The identifier of the tunnel peer, which is used in Phase 1 negotiations. It can contain at most 100 characters. The default value is the IP address of the customer gateway that is associated with the tunnel.
        RemoteId supports FQDNs. If you use an FQDN, we recommend that you set the negotiation mode to aggressive.
        """
        return pulumi.get(self, "remote_id")


@pulumi.output_type
class ConnectionTunnelOptionsSpecificationTunnelIpsecConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipsecAuthAlg":
            suggest = "ipsec_auth_alg"
        elif key == "ipsecEncAlg":
            suggest = "ipsec_enc_alg"
        elif key == "ipsecLifetime":
            suggest = "ipsec_lifetime"
        elif key == "ipsecPfs":
            suggest = "ipsec_pfs"

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

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

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

    def __init__(__self__, *,
                 ipsec_auth_alg: Optional[str] = None,
                 ipsec_enc_alg: Optional[str] = None,
                 ipsec_lifetime: Optional[int] = None,
                 ipsec_pfs: Optional[str] = None):
        if ipsec_auth_alg is not None:
            pulumi.set(__self__, "ipsec_auth_alg", ipsec_auth_alg)
        if ipsec_enc_alg is not None:
            pulumi.set(__self__, "ipsec_enc_alg", ipsec_enc_alg)
        if ipsec_lifetime is not None:
            pulumi.set(__self__, "ipsec_lifetime", ipsec_lifetime)
        if ipsec_pfs is not None:
            pulumi.set(__self__, "ipsec_pfs", ipsec_pfs)

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

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

    @property
    @pulumi.getter(name="ipsecLifetime")
    def ipsec_lifetime(self) -> Optional[int]:
        return pulumi.get(self, "ipsec_lifetime")

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


@pulumi.output_type
class GatewayVpnAttachmentBgpConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "localAsn":
            suggest = "local_asn"
        elif key == "localBgpIp":
            suggest = "local_bgp_ip"
        elif key == "tunnelCidr":
            suggest = "tunnel_cidr"

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

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

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

    def __init__(__self__, *,
                 enable: Optional[bool] = None,
                 local_asn: Optional[int] = None,
                 local_bgp_ip: Optional[str] = None,
                 tunnel_cidr: Optional[str] = None):
        """
        :param bool enable: Whether to enable BGP.
        :param int local_asn: The ASN on the Alibaba Cloud side.
        :param str local_bgp_ip: The BGP IP address on the Alibaba Cloud side.
        :param str tunnel_cidr: The CIDR block of the IPsec tunnel. The CIDR block belongs to 169.254.0.0/16. The mask of the CIDR block is 30 bits in length.
        """
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if local_asn is not None:
            pulumi.set(__self__, "local_asn", local_asn)
        if local_bgp_ip is not None:
            pulumi.set(__self__, "local_bgp_ip", local_bgp_ip)
        if tunnel_cidr is not None:
            pulumi.set(__self__, "tunnel_cidr", tunnel_cidr)

    @property
    @pulumi.getter
    def enable(self) -> Optional[bool]:
        """
        Whether to enable BGP.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter(name="localAsn")
    def local_asn(self) -> Optional[int]:
        """
        The ASN on the Alibaba Cloud side.
        """
        return pulumi.get(self, "local_asn")

    @property
    @pulumi.getter(name="localBgpIp")
    def local_bgp_ip(self) -> Optional[str]:
        """
        The BGP IP address on the Alibaba Cloud side.
        """
        return pulumi.get(self, "local_bgp_ip")

    @property
    @pulumi.getter(name="tunnelCidr")
    def tunnel_cidr(self) -> Optional[str]:
        """
        The CIDR block of the IPsec tunnel. The CIDR block belongs to 169.254.0.0/16. The mask of the CIDR block is 30 bits in length.
        """
        return pulumi.get(self, "tunnel_cidr")


@pulumi.output_type
class GatewayVpnAttachmentHealthCheckConfig(dict):
    def __init__(__self__, *,
                 dip: Optional[str] = None,
                 enable: Optional[bool] = None,
                 interval: Optional[int] = None,
                 policy: Optional[str] = None,
                 retry: Optional[int] = None,
                 sip: Optional[str] = None):
        """
        :param str dip: The destination IP address that is used for health checks.
        :param bool enable: Specifies whether to enable health checks.
        :param int interval: The interval between two consecutive health checks. Unit: seconds.
        :param str policy: Whether to revoke the published route when the health check fails. Valid values: `revoke_route` or `reserve_route`.
        :param int retry: The maximum number of health check retries.
        :param str sip: The source IP address that is used for health checks.
        """
        if dip is not None:
            pulumi.set(__self__, "dip", dip)
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)
        if retry is not None:
            pulumi.set(__self__, "retry", retry)
        if sip is not None:
            pulumi.set(__self__, "sip", sip)

    @property
    @pulumi.getter
    def dip(self) -> Optional[str]:
        """
        The destination IP address that is used for health checks.
        """
        return pulumi.get(self, "dip")

    @property
    @pulumi.getter
    def enable(self) -> Optional[bool]:
        """
        Specifies whether to enable health checks.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        The interval between two consecutive health checks. Unit: seconds.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def policy(self) -> Optional[str]:
        """
        Whether to revoke the published route when the health check fails. Valid values: `revoke_route` or `reserve_route`.
        """
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def retry(self) -> Optional[int]:
        """
        The maximum number of health check retries.
        """
        return pulumi.get(self, "retry")

    @property
    @pulumi.getter
    def sip(self) -> Optional[str]:
        """
        The source IP address that is used for health checks.
        """
        return pulumi.get(self, "sip")


@pulumi.output_type
class GatewayVpnAttachmentIkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ikeAuthAlg":
            suggest = "ike_auth_alg"
        elif key == "ikeEncAlg":
            suggest = "ike_enc_alg"
        elif key == "ikeLifetime":
            suggest = "ike_lifetime"
        elif key == "ikeMode":
            suggest = "ike_mode"
        elif key == "ikePfs":
            suggest = "ike_pfs"
        elif key == "ikeVersion":
            suggest = "ike_version"
        elif key == "localId":
            suggest = "local_id"
        elif key == "remoteId":
            suggest = "remote_id"

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

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

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

    def __init__(__self__, *,
                 ike_auth_alg: Optional[str] = None,
                 ike_enc_alg: Optional[str] = None,
                 ike_lifetime: Optional[int] = None,
                 ike_mode: Optional[str] = None,
                 ike_pfs: Optional[str] = None,
                 ike_version: Optional[str] = None,
                 local_id: Optional[str] = None,
                 psk: Optional[str] = None,
                 remote_id: Optional[str] = None):
        """
        :param str ike_auth_alg: IKE authentication algorithm supports sha1 and MD5.
        :param str ike_enc_alg: The encryption algorithm of phase-one negotiation. Valid value: aes | aes192 | aes256 | des | 3des. Default Valid value: aes.
        :param int ike_lifetime: The SA lifecycle as the result of phase-one negotiation. The valid value of n is [0, 86400], the unit is second and the default value is 86400.
        :param str ike_mode: The negotiation mode of IKE V1. Valid value: main (main mode) | aggressive (aggressive mode). Default value: `main`.
        :param str ike_pfs: The Diffie-Hellman key exchange algorithm used by phase-one negotiation. Valid value: group1 | group2 | group5 | group14 | group24. Default value: group2
        :param str ike_version: The version of the IKE protocol. Valid value: `ikev1`, `ikev2`. Default value: `ikev1`.
        :param str local_id: The local ID, which supports the FQDN and IP formats. The current VPN gateway IP address is selected by default.
        :param str psk: Used for authentication between the IPsec VPN gateway and the customer gateway.
        :param str remote_id: The peer ID, which supports FQDN and IP formats. By default, the IP address of the currently selected user gateway.
        """
        if ike_auth_alg is not None:
            pulumi.set(__self__, "ike_auth_alg", ike_auth_alg)
        if ike_enc_alg is not None:
            pulumi.set(__self__, "ike_enc_alg", ike_enc_alg)
        if ike_lifetime is not None:
            pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        if ike_mode is not None:
            pulumi.set(__self__, "ike_mode", ike_mode)
        if ike_pfs is not None:
            pulumi.set(__self__, "ike_pfs", ike_pfs)
        if ike_version is not None:
            pulumi.set(__self__, "ike_version", ike_version)
        if local_id is not None:
            pulumi.set(__self__, "local_id", local_id)
        if psk is not None:
            pulumi.set(__self__, "psk", psk)
        if remote_id is not None:
            pulumi.set(__self__, "remote_id", remote_id)

    @property
    @pulumi.getter(name="ikeAuthAlg")
    def ike_auth_alg(self) -> Optional[str]:
        """
        IKE authentication algorithm supports sha1 and MD5.
        """
        return pulumi.get(self, "ike_auth_alg")

    @property
    @pulumi.getter(name="ikeEncAlg")
    def ike_enc_alg(self) -> Optional[str]:
        """
        The encryption algorithm of phase-one negotiation. Valid value: aes | aes192 | aes256 | des | 3des. Default Valid value: aes.
        """
        return pulumi.get(self, "ike_enc_alg")

    @property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> Optional[int]:
        """
        The SA lifecycle as the result of phase-one negotiation. The valid value of n is [0, 86400], the unit is second and the default value is 86400.
        """
        return pulumi.get(self, "ike_lifetime")

    @property
    @pulumi.getter(name="ikeMode")
    def ike_mode(self) -> Optional[str]:
        """
        The negotiation mode of IKE V1. Valid value: main (main mode) | aggressive (aggressive mode). Default value: `main`.
        """
        return pulumi.get(self, "ike_mode")

    @property
    @pulumi.getter(name="ikePfs")
    def ike_pfs(self) -> Optional[str]:
        """
        The Diffie-Hellman key exchange algorithm used by phase-one negotiation. Valid value: group1 | group2 | group5 | group14 | group24. Default value: group2
        """
        return pulumi.get(self, "ike_pfs")

    @property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> Optional[str]:
        """
        The version of the IKE protocol. Valid value: `ikev1`, `ikev2`. Default value: `ikev1`.
        """
        return pulumi.get(self, "ike_version")

    @property
    @pulumi.getter(name="localId")
    def local_id(self) -> Optional[str]:
        """
        The local ID, which supports the FQDN and IP formats. The current VPN gateway IP address is selected by default.
        """
        return pulumi.get(self, "local_id")

    @property
    @pulumi.getter
    def psk(self) -> Optional[str]:
        """
        Used for authentication between the IPsec VPN gateway and the customer gateway.
        """
        return pulumi.get(self, "psk")

    @property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> Optional[str]:
        """
        The peer ID, which supports FQDN and IP formats. By default, the IP address of the currently selected user gateway.
        """
        return pulumi.get(self, "remote_id")


@pulumi.output_type
class GatewayVpnAttachmentIpsecConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipsecAuthAlg":
            suggest = "ipsec_auth_alg"
        elif key == "ipsecEncAlg":
            suggest = "ipsec_enc_alg"
        elif key == "ipsecLifetime":
            suggest = "ipsec_lifetime"
        elif key == "ipsecPfs":
            suggest = "ipsec_pfs"

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

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

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

    def __init__(__self__, *,
                 ipsec_auth_alg: Optional[str] = None,
                 ipsec_enc_alg: Optional[str] = None,
                 ipsec_lifetime: Optional[int] = None,
                 ipsec_pfs: Optional[str] = None):
        """
        :param str ipsec_auth_alg: The authentication algorithm of phase-two negotiation. Valid value: md5 | sha1 | sha256 | sha384 | sha512 |. Default value: sha1
        :param str ipsec_enc_alg: The encryption algorithm of phase-two negotiation. Valid value: aes | aes192 | aes256 | des | 3des. Default value: aes
        :param int ipsec_lifetime: The SA lifecycle as the result of phase-two negotiation. The valid value is [0, 86400], the unit is second and the default value is 86400.
        :param str ipsec_pfs: The Diffie-Hellman key exchange algorithm used by phase-two negotiation. Valid value: group1 | group2 | group5 | group14 | group24| disabled. Default value: group2
        """
        if ipsec_auth_alg is not None:
            pulumi.set(__self__, "ipsec_auth_alg", ipsec_auth_alg)
        if ipsec_enc_alg is not None:
            pulumi.set(__self__, "ipsec_enc_alg", ipsec_enc_alg)
        if ipsec_lifetime is not None:
            pulumi.set(__self__, "ipsec_lifetime", ipsec_lifetime)
        if ipsec_pfs is not None:
            pulumi.set(__self__, "ipsec_pfs", ipsec_pfs)

    @property
    @pulumi.getter(name="ipsecAuthAlg")
    def ipsec_auth_alg(self) -> Optional[str]:
        """
        The authentication algorithm of phase-two negotiation. Valid value: md5 | sha1 | sha256 | sha384 | sha512 |. Default value: sha1
        """
        return pulumi.get(self, "ipsec_auth_alg")

    @property
    @pulumi.getter(name="ipsecEncAlg")
    def ipsec_enc_alg(self) -> Optional[str]:
        """
        The encryption algorithm of phase-two negotiation. Valid value: aes | aes192 | aes256 | des | 3des. Default value: aes
        """
        return pulumi.get(self, "ipsec_enc_alg")

    @property
    @pulumi.getter(name="ipsecLifetime")
    def ipsec_lifetime(self) -> Optional[int]:
        """
        The SA lifecycle as the result of phase-two negotiation. The valid value is [0, 86400], the unit is second and the default value is 86400.
        """
        return pulumi.get(self, "ipsec_lifetime")

    @property
    @pulumi.getter(name="ipsecPfs")
    def ipsec_pfs(self) -> Optional[str]:
        """
        The Diffie-Hellman key exchange algorithm used by phase-two negotiation. Valid value: group1 | group2 | group5 | group14 | group24| disabled. Default value: group2
        """
        return pulumi.get(self, "ipsec_pfs")


@pulumi.output_type
class IpsecServerIkeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ikeAuthAlg":
            suggest = "ike_auth_alg"
        elif key == "ikeEncAlg":
            suggest = "ike_enc_alg"
        elif key == "ikeLifetime":
            suggest = "ike_lifetime"
        elif key == "ikeMode":
            suggest = "ike_mode"
        elif key == "ikePfs":
            suggest = "ike_pfs"
        elif key == "ikeVersion":
            suggest = "ike_version"
        elif key == "localId":
            suggest = "local_id"
        elif key == "remoteId":
            suggest = "remote_id"

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

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

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

    def __init__(__self__, *,
                 ike_auth_alg: Optional[str] = None,
                 ike_enc_alg: Optional[str] = None,
                 ike_lifetime: Optional[int] = None,
                 ike_mode: Optional[str] = None,
                 ike_pfs: Optional[str] = None,
                 ike_version: Optional[str] = None,
                 local_id: Optional[str] = None,
                 remote_id: Optional[str] = None):
        """
        :param str ike_auth_alg: The authentication algorithm that is used in Phase 1 negotiations. Default value: `sha1`.
        :param str ike_enc_alg: The encryption algorithm that is used in Phase 1 negotiations. Default value: `aes`.
        :param int ike_lifetime: IkeLifetime: the SA lifetime determined by Phase 1 negotiations. Valid values: `0` to `86400`. Default value: `86400`. Unit: `seconds`.
        :param str ike_mode: The IKE negotiation mode. Default value: `main`.
        :param str ike_pfs: The Diffie-Hellman key exchange algorithm that is used in Phase 1 negotiations. Default value: `group2`.
        :param str ike_version: The IKE version. Valid values: `ikev1` and `ikev2`. Default value: `ikev2`.
        :param str local_id: The identifier of the IPsec server. The value can be a fully qualified domain name (FQDN) or an IP address. The default value is the public IP address of the VPN gateway.
        :param str remote_id: The identifier of the customer gateway. The value can be an FQDN or an IP address. By default, this parameter is not specified.
        """
        if ike_auth_alg is not None:
            pulumi.set(__self__, "ike_auth_alg", ike_auth_alg)
        if ike_enc_alg is not None:
            pulumi.set(__self__, "ike_enc_alg", ike_enc_alg)
        if ike_lifetime is not None:
            pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        if ike_mode is not None:
            pulumi.set(__self__, "ike_mode", ike_mode)
        if ike_pfs is not None:
            pulumi.set(__self__, "ike_pfs", ike_pfs)
        if ike_version is not None:
            pulumi.set(__self__, "ike_version", ike_version)
        if local_id is not None:
            pulumi.set(__self__, "local_id", local_id)
        if remote_id is not None:
            pulumi.set(__self__, "remote_id", remote_id)

    @property
    @pulumi.getter(name="ikeAuthAlg")
    def ike_auth_alg(self) -> Optional[str]:
        """
        The authentication algorithm that is used in Phase 1 negotiations. Default value: `sha1`.
        """
        return pulumi.get(self, "ike_auth_alg")

    @property
    @pulumi.getter(name="ikeEncAlg")
    def ike_enc_alg(self) -> Optional[str]:
        """
        The encryption algorithm that is used in Phase 1 negotiations. Default value: `aes`.
        """
        return pulumi.get(self, "ike_enc_alg")

    @property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> Optional[int]:
        """
        IkeLifetime: the SA lifetime determined by Phase 1 negotiations. Valid values: `0` to `86400`. Default value: `86400`. Unit: `seconds`.
        """
        return pulumi.get(self, "ike_lifetime")

    @property
    @pulumi.getter(name="ikeMode")
    def ike_mode(self) -> Optional[str]:
        """
        The IKE negotiation mode. Default value: `main`.
        """
        return pulumi.get(self, "ike_mode")

    @property
    @pulumi.getter(name="ikePfs")
    def ike_pfs(self) -> Optional[str]:
        """
        The Diffie-Hellman key exchange algorithm that is used in Phase 1 negotiations. Default value: `group2`.
        """
        return pulumi.get(self, "ike_pfs")

    @property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> Optional[str]:
        """
        The IKE version. Valid values: `ikev1` and `ikev2`. Default value: `ikev2`.
        """
        return pulumi.get(self, "ike_version")

    @property
    @pulumi.getter(name="localId")
    def local_id(self) -> Optional[str]:
        """
        The identifier of the IPsec server. The value can be a fully qualified domain name (FQDN) or an IP address. The default value is the public IP address of the VPN gateway.
        """
        return pulumi.get(self, "local_id")

    @property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> Optional[str]:
        """
        The identifier of the customer gateway. The value can be an FQDN or an IP address. By default, this parameter is not specified.
        """
        return pulumi.get(self, "remote_id")


@pulumi.output_type
class IpsecServerIpsecConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipsecAuthAlg":
            suggest = "ipsec_auth_alg"
        elif key == "ipsecEncAlg":
            suggest = "ipsec_enc_alg"
        elif key == "ipsecLifetime":
            suggest = "ipsec_lifetime"
        elif key == "ipsecPfs":
            suggest = "ipsec_pfs"

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

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

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

    def __init__(__self__, *,
                 ipsec_auth_alg: Optional[str] = None,
                 ipsec_enc_alg: Optional[str] = None,
                 ipsec_lifetime: Optional[int] = None,
                 ipsec_pfs: Optional[str] = None):
        """
        :param str ipsec_auth_alg: The authentication algorithm that is used in Phase 2 negotiations. Default value: `sha1`.
        :param str ipsec_enc_alg: The encryption algorithm that is used in Phase 2 negotiations. Default value: `aes`.
        :param int ipsec_lifetime: The SA lifetime determined by Phase 2 negotiations. Valid values: `0` to `86400`. Default value: `86400`. Unit: `seconds`.
        :param str ipsec_pfs: Forwards packets of all protocols. The Diffie-Hellman key exchange algorithm used in Phase 2 negotiations. Default value: `group2`.
        """
        if ipsec_auth_alg is not None:
            pulumi.set(__self__, "ipsec_auth_alg", ipsec_auth_alg)
        if ipsec_enc_alg is not None:
            pulumi.set(__self__, "ipsec_enc_alg", ipsec_enc_alg)
        if ipsec_lifetime is not None:
            pulumi.set(__self__, "ipsec_lifetime", ipsec_lifetime)
        if ipsec_pfs is not None:
            pulumi.set(__self__, "ipsec_pfs", ipsec_pfs)

    @property
    @pulumi.getter(name="ipsecAuthAlg")
    def ipsec_auth_alg(self) -> Optional[str]:
        """
        The authentication algorithm that is used in Phase 2 negotiations. Default value: `sha1`.
        """
        return pulumi.get(self, "ipsec_auth_alg")

    @property
    @pulumi.getter(name="ipsecEncAlg")
    def ipsec_enc_alg(self) -> Optional[str]:
        """
        The encryption algorithm that is used in Phase 2 negotiations. Default value: `aes`.
        """
        return pulumi.get(self, "ipsec_enc_alg")

    @property
    @pulumi.getter(name="ipsecLifetime")
    def ipsec_lifetime(self) -> Optional[int]:
        """
        The SA lifetime determined by Phase 2 negotiations. Valid values: `0` to `86400`. Default value: `86400`. Unit: `seconds`.
        """
        return pulumi.get(self, "ipsec_lifetime")

    @property
    @pulumi.getter(name="ipsecPfs")
    def ipsec_pfs(self) -> Optional[str]:
        """
        Forwards packets of all protocols. The Diffie-Hellman key exchange algorithm used in Phase 2 negotiations. Default value: `group2`.
        """
        return pulumi.get(self, "ipsec_pfs")


@pulumi.output_type
class GetConnectionsConnectionResult(dict):
    def __init__(__self__, *,
                 create_time: str,
                 customer_gateway_id: str,
                 effect_immediately: bool,
                 enable_dpd: bool,
                 enable_nat_traversal: bool,
                 enable_tunnels_bgp: bool,
                 id: str,
                 local_subnet: str,
                 name: str,
                 remote_subnet: str,
                 status: str,
                 tunnel_options_specifications: Sequence['outputs.GetConnectionsConnectionTunnelOptionsSpecificationResult'],
                 vpn_gateway_id: str,
                 ike_configs: Optional[Sequence['outputs.GetConnectionsConnectionIkeConfigResult']] = None,
                 ipsec_configs: Optional[Sequence['outputs.GetConnectionsConnectionIpsecConfigResult']] = None,
                 vco_health_checks: Optional[Sequence['outputs.GetConnectionsConnectionVcoHealthCheckResult']] = None,
                 vpn_bgp_configs: Optional[Sequence['outputs.GetConnectionsConnectionVpnBgpConfigResult']] = None):
        """
        :param str customer_gateway_id: Use the VPN customer gateway ID as the search key.
        :param bool enable_dpd: Wether enable Dpd detection.
        :param bool enable_nat_traversal: enable nat traversal.
        :param bool enable_tunnels_bgp: Enable tunnel bgp.
        :param str id: ID of the VPN connection.
        :param str local_subnet: The local subnet of the VPN connection.
        :param str name: The name of the VPN connection.
        :param str remote_subnet: The remote subnet of the VPN connection.
        :param str status: The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        :param Sequence['GetConnectionsConnectionTunnelOptionsSpecificationArgs'] tunnel_options_specifications: The tunnel_options_specification supports the following:
        :param str vpn_gateway_id: Use the VPN gateway ID as the search key.
        :param Sequence['GetConnectionsConnectionIkeConfigArgs'] ike_configs: The ike_config mapping supports the following:
        :param Sequence['GetConnectionsConnectionIpsecConfigArgs'] ipsec_configs: The ipsec_config mapping supports the following:
        :param Sequence['GetConnectionsConnectionVpnBgpConfigArgs'] vpn_bgp_configs: The vpn_bgp_config mapping supports the following:
        """
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "customer_gateway_id", customer_gateway_id)
        pulumi.set(__self__, "effect_immediately", effect_immediately)
        pulumi.set(__self__, "enable_dpd", enable_dpd)
        pulumi.set(__self__, "enable_nat_traversal", enable_nat_traversal)
        pulumi.set(__self__, "enable_tunnels_bgp", enable_tunnels_bgp)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "local_subnet", local_subnet)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "remote_subnet", remote_subnet)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tunnel_options_specifications", tunnel_options_specifications)
        pulumi.set(__self__, "vpn_gateway_id", vpn_gateway_id)
        if ike_configs is not None:
            pulumi.set(__self__, "ike_configs", ike_configs)
        if ipsec_configs is not None:
            pulumi.set(__self__, "ipsec_configs", ipsec_configs)
        if vco_health_checks is not None:
            pulumi.set(__self__, "vco_health_checks", vco_health_checks)
        if vpn_bgp_configs is not None:
            pulumi.set(__self__, "vpn_bgp_configs", vpn_bgp_configs)

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

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

    @property
    @pulumi.getter(name="effectImmediately")
    def effect_immediately(self) -> bool:
        return pulumi.get(self, "effect_immediately")

    @property
    @pulumi.getter(name="enableDpd")
    def enable_dpd(self) -> bool:
        """
        Wether enable Dpd detection.
        """
        return pulumi.get(self, "enable_dpd")

    @property
    @pulumi.getter(name="enableNatTraversal")
    def enable_nat_traversal(self) -> bool:
        """
        enable nat traversal.
        """
        return pulumi.get(self, "enable_nat_traversal")

    @property
    @pulumi.getter(name="enableTunnelsBgp")
    def enable_tunnels_bgp(self) -> bool:
        """
        Enable tunnel bgp.
        """
        return pulumi.get(self, "enable_tunnels_bgp")

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

    @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
    def name(self) -> str:
        """
        The name of the VPN connection.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="tunnelOptionsSpecifications")
    def tunnel_options_specifications(self) -> Sequence['outputs.GetConnectionsConnectionTunnelOptionsSpecificationResult']:
        """
        The tunnel_options_specification supports the following:
        """
        return pulumi.get(self, "tunnel_options_specifications")

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

    @property
    @pulumi.getter(name="ikeConfigs")
    def ike_configs(self) -> Optional[Sequence['outputs.GetConnectionsConnectionIkeConfigResult']]:
        """
        The ike_config mapping supports the following:
        """
        return pulumi.get(self, "ike_configs")

    @property
    @pulumi.getter(name="ipsecConfigs")
    def ipsec_configs(self) -> Optional[Sequence['outputs.GetConnectionsConnectionIpsecConfigResult']]:
        """
        The ipsec_config mapping supports the following:
        """
        return pulumi.get(self, "ipsec_configs")

    @property
    @pulumi.getter(name="vcoHealthChecks")
    def vco_health_checks(self) -> Optional[Sequence['outputs.GetConnectionsConnectionVcoHealthCheckResult']]:
        return pulumi.get(self, "vco_health_checks")

    @property
    @pulumi.getter(name="vpnBgpConfigs")
    def vpn_bgp_configs(self) -> Optional[Sequence['outputs.GetConnectionsConnectionVpnBgpConfigResult']]:
        """
        The vpn_bgp_config mapping supports the following:
        """
        return pulumi.get(self, "vpn_bgp_configs")


@pulumi.output_type
class GetConnectionsConnectionIkeConfigResult(dict):
    def __init__(__self__, *,
                 ike_auth_alg: Optional[str] = None,
                 ike_enc_alg: Optional[str] = None,
                 ike_lifetime: Optional[int] = None,
                 ike_local_id: Optional[str] = None,
                 ike_mode: Optional[str] = None,
                 ike_pfs: Optional[str] = None,
                 ike_remote_id: Optional[str] = None,
                 ike_version: Optional[str] = None,
                 psk: Optional[str] = None):
        """
        :param str ike_auth_alg: IKE auth Algorithm.
        :param str ike_enc_alg: IKE encript algorithm.
        :param int ike_lifetime: IKE lifetime.
        :param str ike_local_id: The identification of the VPN gateway.
        :param str ike_mode: IKE Mode.
        :param str ike_pfs: DH Group.
        :param str ike_remote_id: The identification of the customer gateway.
        :param str ike_version: IKE Version.
        :param str psk: Preshared secret key.
        """
        if ike_auth_alg is not None:
            pulumi.set(__self__, "ike_auth_alg", ike_auth_alg)
        if ike_enc_alg is not None:
            pulumi.set(__self__, "ike_enc_alg", ike_enc_alg)
        if ike_lifetime is not None:
            pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        if ike_local_id is not None:
            pulumi.set(__self__, "ike_local_id", ike_local_id)
        if ike_mode is not None:
            pulumi.set(__self__, "ike_mode", ike_mode)
        if ike_pfs is not None:
            pulumi.set(__self__, "ike_pfs", ike_pfs)
        if ike_remote_id is not None:
            pulumi.set(__self__, "ike_remote_id", ike_remote_id)
        if ike_version is not None:
            pulumi.set(__self__, "ike_version", ike_version)
        if psk is not None:
            pulumi.set(__self__, "psk", psk)

    @property
    @pulumi.getter(name="ikeAuthAlg")
    def ike_auth_alg(self) -> Optional[str]:
        """
        IKE auth Algorithm.
        """
        return pulumi.get(self, "ike_auth_alg")

    @property
    @pulumi.getter(name="ikeEncAlg")
    def ike_enc_alg(self) -> Optional[str]:
        """
        IKE encript algorithm.
        """
        return pulumi.get(self, "ike_enc_alg")

    @property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> Optional[int]:
        """
        IKE lifetime.
        """
        return pulumi.get(self, "ike_lifetime")

    @property
    @pulumi.getter(name="ikeLocalId")
    def ike_local_id(self) -> Optional[str]:
        """
        The identification of the VPN gateway.
        """
        return pulumi.get(self, "ike_local_id")

    @property
    @pulumi.getter(name="ikeMode")
    def ike_mode(self) -> Optional[str]:
        """
        IKE Mode.
        """
        return pulumi.get(self, "ike_mode")

    @property
    @pulumi.getter(name="ikePfs")
    def ike_pfs(self) -> Optional[str]:
        """
        DH Group.
        """
        return pulumi.get(self, "ike_pfs")

    @property
    @pulumi.getter(name="ikeRemoteId")
    def ike_remote_id(self) -> Optional[str]:
        """
        The identification of the customer gateway.
        """
        return pulumi.get(self, "ike_remote_id")

    @property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> Optional[str]:
        """
        IKE Version.
        """
        return pulumi.get(self, "ike_version")

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


@pulumi.output_type
class GetConnectionsConnectionIpsecConfigResult(dict):
    def __init__(__self__, *,
                 ipsec_auth_alg: Optional[str] = None,
                 ipsec_enc_alg: Optional[str] = None,
                 ipsec_lifetime: Optional[int] = None,
                 ipsec_pfs: Optional[str] = None):
        """
        :param str ipsec_auth_alg: IPsec Auth algorithm.
        :param str ipsec_enc_alg: IPsec Encript algorithm.
        :param int ipsec_lifetime: IPsec lifetime.
        :param str ipsec_pfs: DH Group.
        """
        if ipsec_auth_alg is not None:
            pulumi.set(__self__, "ipsec_auth_alg", ipsec_auth_alg)
        if ipsec_enc_alg is not None:
            pulumi.set(__self__, "ipsec_enc_alg", ipsec_enc_alg)
        if ipsec_lifetime is not None:
            pulumi.set(__self__, "ipsec_lifetime", ipsec_lifetime)
        if ipsec_pfs is not None:
            pulumi.set(__self__, "ipsec_pfs", ipsec_pfs)

    @property
    @pulumi.getter(name="ipsecAuthAlg")
    def ipsec_auth_alg(self) -> Optional[str]:
        """
        IPsec Auth algorithm.
        """
        return pulumi.get(self, "ipsec_auth_alg")

    @property
    @pulumi.getter(name="ipsecEncAlg")
    def ipsec_enc_alg(self) -> Optional[str]:
        """
        IPsec Encript algorithm.
        """
        return pulumi.get(self, "ipsec_enc_alg")

    @property
    @pulumi.getter(name="ipsecLifetime")
    def ipsec_lifetime(self) -> Optional[int]:
        """
        IPsec lifetime.
        """
        return pulumi.get(self, "ipsec_lifetime")

    @property
    @pulumi.getter(name="ipsecPfs")
    def ipsec_pfs(self) -> Optional[str]:
        """
        DH Group.
        """
        return pulumi.get(self, "ipsec_pfs")


@pulumi.output_type
class GetConnectionsConnectionTunnelOptionsSpecificationResult(dict):
    def __init__(__self__, *,
                 customer_gateway_id: str,
                 enable_dpd: bool,
                 enable_nat_traversal: bool,
                 internet_ip: str,
                 role: str,
                 state: str,
                 status: str,
                 tunnel_bgp_config: 'outputs.GetConnectionsConnectionTunnelOptionsSpecificationTunnelBgpConfigResult',
                 tunnel_id: str,
                 tunnel_ike_config: 'outputs.GetConnectionsConnectionTunnelOptionsSpecificationTunnelIkeConfigResult',
                 tunnel_ipsec_config: 'outputs.GetConnectionsConnectionTunnelOptionsSpecificationTunnelIpsecConfigResult',
                 zone_no: str):
        """
        :param str customer_gateway_id: Use the VPN customer gateway ID as the search key.
        :param bool enable_dpd: Wether enable Dpd detection.
        :param bool enable_nat_traversal: enable nat traversal.
        :param str role: The role of Tunnel.
        :param str status: The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        :param 'GetConnectionsConnectionTunnelOptionsSpecificationTunnelBgpConfigArgs' tunnel_bgp_config: The bgp config of Tunnel.
        :param 'GetConnectionsConnectionTunnelOptionsSpecificationTunnelIkeConfigArgs' tunnel_ike_config: The configuration of Phase 1 negotiations in Tunnel.
        :param 'GetConnectionsConnectionTunnelOptionsSpecificationTunnelIpsecConfigArgs' tunnel_ipsec_config: IPsec configuration in Tunnel.
        """
        pulumi.set(__self__, "customer_gateway_id", customer_gateway_id)
        pulumi.set(__self__, "enable_dpd", enable_dpd)
        pulumi.set(__self__, "enable_nat_traversal", enable_nat_traversal)
        pulumi.set(__self__, "internet_ip", internet_ip)
        pulumi.set(__self__, "role", role)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tunnel_bgp_config", tunnel_bgp_config)
        pulumi.set(__self__, "tunnel_id", tunnel_id)
        pulumi.set(__self__, "tunnel_ike_config", tunnel_ike_config)
        pulumi.set(__self__, "tunnel_ipsec_config", tunnel_ipsec_config)
        pulumi.set(__self__, "zone_no", zone_no)

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

    @property
    @pulumi.getter(name="enableDpd")
    def enable_dpd(self) -> bool:
        """
        Wether enable Dpd detection.
        """
        return pulumi.get(self, "enable_dpd")

    @property
    @pulumi.getter(name="enableNatTraversal")
    def enable_nat_traversal(self) -> bool:
        """
        enable nat traversal.
        """
        return pulumi.get(self, "enable_nat_traversal")

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

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

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

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="tunnelBgpConfig")
    def tunnel_bgp_config(self) -> 'outputs.GetConnectionsConnectionTunnelOptionsSpecificationTunnelBgpConfigResult':
        """
        The bgp config of Tunnel.
        """
        return pulumi.get(self, "tunnel_bgp_config")

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

    @property
    @pulumi.getter(name="tunnelIkeConfig")
    def tunnel_ike_config(self) -> 'outputs.GetConnectionsConnectionTunnelOptionsSpecificationTunnelIkeConfigResult':
        """
        The configuration of Phase 1 negotiations in Tunnel.
        """
        return pulumi.get(self, "tunnel_ike_config")

    @property
    @pulumi.getter(name="tunnelIpsecConfig")
    def tunnel_ipsec_config(self) -> 'outputs.GetConnectionsConnectionTunnelOptionsSpecificationTunnelIpsecConfigResult':
        """
        IPsec configuration in Tunnel.
        """
        return pulumi.get(self, "tunnel_ipsec_config")

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


@pulumi.output_type
class GetConnectionsConnectionTunnelOptionsSpecificationTunnelBgpConfigResult(dict):
    def __init__(__self__, *,
                 bgp_status: str,
                 local_asn: str,
                 local_bgp_ip: str,
                 peer_asn: str,
                 peer_bgp_ip: str,
                 tunnel_cidr: str):
        """
        :param str local_asn: Local asn.
        :param str local_bgp_ip: Local bgp IP.
        :param str peer_asn: The counterpart autonomous system number.
        :param str peer_bgp_ip: The BGP address on the other side.
        :param str tunnel_cidr: BGP Tunnel CIDR.
        """
        pulumi.set(__self__, "bgp_status", bgp_status)
        pulumi.set(__self__, "local_asn", local_asn)
        pulumi.set(__self__, "local_bgp_ip", local_bgp_ip)
        pulumi.set(__self__, "peer_asn", peer_asn)
        pulumi.set(__self__, "peer_bgp_ip", peer_bgp_ip)
        pulumi.set(__self__, "tunnel_cidr", tunnel_cidr)

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

    @property
    @pulumi.getter(name="localAsn")
    def local_asn(self) -> str:
        """
        Local asn.
        """
        return pulumi.get(self, "local_asn")

    @property
    @pulumi.getter(name="localBgpIp")
    def local_bgp_ip(self) -> str:
        """
        Local bgp IP.
        """
        return pulumi.get(self, "local_bgp_ip")

    @property
    @pulumi.getter(name="peerAsn")
    def peer_asn(self) -> str:
        """
        The counterpart autonomous system number.
        """
        return pulumi.get(self, "peer_asn")

    @property
    @pulumi.getter(name="peerBgpIp")
    def peer_bgp_ip(self) -> str:
        """
        The BGP address on the other side.
        """
        return pulumi.get(self, "peer_bgp_ip")

    @property
    @pulumi.getter(name="tunnelCidr")
    def tunnel_cidr(self) -> str:
        """
        BGP Tunnel CIDR.
        """
        return pulumi.get(self, "tunnel_cidr")


@pulumi.output_type
class GetConnectionsConnectionTunnelOptionsSpecificationTunnelIkeConfigResult(dict):
    def __init__(__self__, *,
                 ike_auth_alg: str,
                 ike_enc_alg: str,
                 ike_lifetime: int,
                 ike_mode: str,
                 ike_pfs: str,
                 ike_version: str,
                 local_id: str,
                 psk: str,
                 remote_id: str):
        """
        :param str ike_auth_alg: IKE auth Algorithm.
        :param str ike_enc_alg: IKE encript algorithm.
        :param int ike_lifetime: IKE lifetime.
        :param str ike_mode: IKE Mode.
        :param str ike_pfs: DH Group.
        :param str ike_version: IKE Version.
        :param str local_id: The local Id.
        :param str psk: Preshared secret key.
        :param str remote_id: Remote ID.
        """
        pulumi.set(__self__, "ike_auth_alg", ike_auth_alg)
        pulumi.set(__self__, "ike_enc_alg", ike_enc_alg)
        pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        pulumi.set(__self__, "ike_mode", ike_mode)
        pulumi.set(__self__, "ike_pfs", ike_pfs)
        pulumi.set(__self__, "ike_version", ike_version)
        pulumi.set(__self__, "local_id", local_id)
        pulumi.set(__self__, "psk", psk)
        pulumi.set(__self__, "remote_id", remote_id)

    @property
    @pulumi.getter(name="ikeAuthAlg")
    def ike_auth_alg(self) -> str:
        """
        IKE auth Algorithm.
        """
        return pulumi.get(self, "ike_auth_alg")

    @property
    @pulumi.getter(name="ikeEncAlg")
    def ike_enc_alg(self) -> str:
        """
        IKE encript algorithm.
        """
        return pulumi.get(self, "ike_enc_alg")

    @property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> int:
        """
        IKE lifetime.
        """
        return pulumi.get(self, "ike_lifetime")

    @property
    @pulumi.getter(name="ikeMode")
    def ike_mode(self) -> str:
        """
        IKE Mode.
        """
        return pulumi.get(self, "ike_mode")

    @property
    @pulumi.getter(name="ikePfs")
    def ike_pfs(self) -> str:
        """
        DH Group.
        """
        return pulumi.get(self, "ike_pfs")

    @property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> str:
        """
        IKE Version.
        """
        return pulumi.get(self, "ike_version")

    @property
    @pulumi.getter(name="localId")
    def local_id(self) -> str:
        """
        The local Id.
        """
        return pulumi.get(self, "local_id")

    @property
    @pulumi.getter
    def psk(self) -> str:
        """
        Preshared secret key.
        """
        return pulumi.get(self, "psk")

    @property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> str:
        """
        Remote ID.
        """
        return pulumi.get(self, "remote_id")


@pulumi.output_type
class GetConnectionsConnectionTunnelOptionsSpecificationTunnelIpsecConfigResult(dict):
    def __init__(__self__, *,
                 ipsec_auth_alg: str,
                 ipsec_enc_alg: str,
                 ipsec_lifetime: int,
                 ipsec_pfs: str):
        """
        :param str ipsec_auth_alg: IPsec Auth algorithm.
        :param str ipsec_enc_alg: IPsec Encript algorithm.
        :param int ipsec_lifetime: IPsec lifetime.
        :param str ipsec_pfs: DH Group.
        """
        pulumi.set(__self__, "ipsec_auth_alg", ipsec_auth_alg)
        pulumi.set(__self__, "ipsec_enc_alg", ipsec_enc_alg)
        pulumi.set(__self__, "ipsec_lifetime", ipsec_lifetime)
        pulumi.set(__self__, "ipsec_pfs", ipsec_pfs)

    @property
    @pulumi.getter(name="ipsecAuthAlg")
    def ipsec_auth_alg(self) -> str:
        """
        IPsec Auth algorithm.
        """
        return pulumi.get(self, "ipsec_auth_alg")

    @property
    @pulumi.getter(name="ipsecEncAlg")
    def ipsec_enc_alg(self) -> str:
        """
        IPsec Encript algorithm.
        """
        return pulumi.get(self, "ipsec_enc_alg")

    @property
    @pulumi.getter(name="ipsecLifetime")
    def ipsec_lifetime(self) -> int:
        """
        IPsec lifetime.
        """
        return pulumi.get(self, "ipsec_lifetime")

    @property
    @pulumi.getter(name="ipsecPfs")
    def ipsec_pfs(self) -> str:
        """
        DH Group.
        """
        return pulumi.get(self, "ipsec_pfs")


@pulumi.output_type
class GetConnectionsConnectionVcoHealthCheckResult(dict):
    def __init__(__self__, *,
                 dip: Optional[str] = None,
                 enable: Optional[str] = None,
                 interval: Optional[int] = None,
                 retry: Optional[int] = None,
                 sip: Optional[str] = None,
                 status: Optional[str] = None):
        """
        :param str dip: The destination ip address.
        :param str enable: The health check on status. Valid values: `true`, `false`.
        :param int interval: The time interval between health checks.
        :param int retry: The number of retries for health checks issued.
        :param str sip: The source ip address.
        :param str status: The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        """
        if dip is not None:
            pulumi.set(__self__, "dip", dip)
        if enable is not None:
            pulumi.set(__self__, "enable", enable)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if retry is not None:
            pulumi.set(__self__, "retry", retry)
        if sip is not None:
            pulumi.set(__self__, "sip", sip)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def dip(self) -> Optional[str]:
        """
        The destination ip address.
        """
        return pulumi.get(self, "dip")

    @property
    @pulumi.getter
    def enable(self) -> Optional[str]:
        """
        The health check on status. Valid values: `true`, `false`.
        """
        return pulumi.get(self, "enable")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        The time interval between health checks.
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def retry(self) -> Optional[int]:
        """
        The number of retries for health checks issued.
        """
        return pulumi.get(self, "retry")

    @property
    @pulumi.getter
    def sip(self) -> Optional[str]:
        """
        The source ip address.
        """
        return pulumi.get(self, "sip")

    @property
    @pulumi.getter
    def status(self) -> Optional[str]:
        """
        The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class GetConnectionsConnectionVpnBgpConfigResult(dict):
    def __init__(__self__, *,
                 auth_key: Optional[str] = None,
                 local_asn: Optional[int] = None,
                 local_bgp_ip: Optional[str] = None,
                 peer_asn: Optional[int] = None,
                 peer_bgp_ip: Optional[str] = None,
                 status: Optional[str] = None,
                 tunnel_cidr: Optional[str] = None):
        """
        :param str auth_key: The authentication keys for BGP routing protocols.
        :param int local_asn: Local asn.
        :param str local_bgp_ip: Local bgp IP.
        :param int peer_asn: The counterpart autonomous system number.
        :param str peer_bgp_ip: The BGP address on the other side.
        :param str status: The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        :param str tunnel_cidr: BGP Tunnel CIDR.
        """
        if auth_key is not None:
            pulumi.set(__self__, "auth_key", auth_key)
        if local_asn is not None:
            pulumi.set(__self__, "local_asn", local_asn)
        if local_bgp_ip is not None:
            pulumi.set(__self__, "local_bgp_ip", local_bgp_ip)
        if peer_asn is not None:
            pulumi.set(__self__, "peer_asn", peer_asn)
        if peer_bgp_ip is not None:
            pulumi.set(__self__, "peer_bgp_ip", peer_bgp_ip)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if tunnel_cidr is not None:
            pulumi.set(__self__, "tunnel_cidr", tunnel_cidr)

    @property
    @pulumi.getter(name="authKey")
    def auth_key(self) -> Optional[str]:
        """
        The authentication keys for BGP routing protocols.
        """
        return pulumi.get(self, "auth_key")

    @property
    @pulumi.getter(name="localAsn")
    def local_asn(self) -> Optional[int]:
        """
        Local asn.
        """
        return pulumi.get(self, "local_asn")

    @property
    @pulumi.getter(name="localBgpIp")
    def local_bgp_ip(self) -> Optional[str]:
        """
        Local bgp IP.
        """
        return pulumi.get(self, "local_bgp_ip")

    @property
    @pulumi.getter(name="peerAsn")
    def peer_asn(self) -> Optional[int]:
        """
        The counterpart autonomous system number.
        """
        return pulumi.get(self, "peer_asn")

    @property
    @pulumi.getter(name="peerBgpIp")
    def peer_bgp_ip(self) -> Optional[str]:
        """
        The BGP address on the other side.
        """
        return pulumi.get(self, "peer_bgp_ip")

    @property
    @pulumi.getter
    def status(self) -> Optional[str]:
        """
        The negotiation status of the BGP routing protocol. Valid values: `success`, `false`.
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="tunnelCidr")
    def tunnel_cidr(self) -> Optional[str]:
        """
        BGP Tunnel CIDR.
        """
        return pulumi.get(self, "tunnel_cidr")


@pulumi.output_type
class GetCustomerGatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 asn: int,
                 create_time: str,
                 description: str,
                 id: str,
                 ip_address: str,
                 name: str):
        """
        :param int asn: The autonomous system number of the local data center gateway device of the VPN customer gateway.
        :param str create_time: The creation time of the VPN customer gateway.
        :param str description: The description of the VPN customer gateway.
        :param str id: ID of the VPN customer gateway .
        :param str ip_address: The ip address of the VPN customer gateway.
        :param str name: The name of the VPN customer gateway.
        """
        pulumi.set(__self__, "asn", asn)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ip_address", ip_address)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def asn(self) -> int:
        """
        The autonomous system number of the local data center gateway device of the VPN customer gateway.
        """
        return pulumi.get(self, "asn")

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

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

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

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> str:
        """
        The ip address of the VPN customer gateway.
        """
        return pulumi.get(self, "ip_address")

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


@pulumi.output_type
class GetGatewayVcoRoutesRouteResult(dict):
    def __init__(__self__, *,
                 as_path: str,
                 create_time: str,
                 id: str,
                 next_hop: str,
                 route_dest: str,
                 source: str,
                 status: str,
                 vpn_connection_id: str,
                 weight: int):
        """
        :param str as_path: List of autonomous system numbers through which BGP routing entries pass.
        :param str create_time: The creation time of the VPN destination route.
        :param str id: The ID of the Vpn Gateway Vco Routes.
        :param str next_hop: The next hop of the destination route.
        :param str route_dest: The destination network segment of the destination route.
        :param str source: The source CIDR block of the destination route.
        :param str status: The status of the vpn route entry.
        :param str vpn_connection_id: The id of the vpn connection.
        :param int weight: The weight value of the destination route.
        """
        pulumi.set(__self__, "as_path", as_path)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "next_hop", next_hop)
        pulumi.set(__self__, "route_dest", route_dest)
        pulumi.set(__self__, "source", source)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpn_connection_id", vpn_connection_id)
        pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="asPath")
    def as_path(self) -> str:
        """
        List of autonomous system numbers through which BGP routing entries pass.
        """
        return pulumi.get(self, "as_path")

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

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

    @property
    @pulumi.getter(name="nextHop")
    def next_hop(self) -> str:
        """
        The next hop of the destination route.
        """
        return pulumi.get(self, "next_hop")

    @property
    @pulumi.getter(name="routeDest")
    def route_dest(self) -> str:
        """
        The destination network segment of the destination route.
        """
        return pulumi.get(self, "route_dest")

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

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

    @property
    @pulumi.getter(name="vpnConnectionId")
    def vpn_connection_id(self) -> str:
        """
        The id of the vpn connection.
        """
        return pulumi.get(self, "vpn_connection_id")

    @property
    @pulumi.getter
    def weight(self) -> int:
        """
        The weight value of the destination route.
        """
        return pulumi.get(self, "weight")


@pulumi.output_type
class GetGatewayVpnAttachmentsAttachmentResult(dict):
    def __init__(__self__, *,
                 bgp_configs: Sequence['outputs.GetGatewayVpnAttachmentsAttachmentBgpConfigResult'],
                 connection_status: str,
                 create_time: str,
                 customer_gateway_id: str,
                 effect_immediately: bool,
                 health_check_configs: Sequence['outputs.GetGatewayVpnAttachmentsAttachmentHealthCheckConfigResult'],
                 id: str,
                 ike_configs: Sequence['outputs.GetGatewayVpnAttachmentsAttachmentIkeConfigResult'],
                 internet_ip: str,
                 ipsec_configs: Sequence['outputs.GetGatewayVpnAttachmentsAttachmentIpsecConfigResult'],
                 local_subnet: str,
                 network_type: str,
                 remote_subnet: str,
                 status: str,
                 vpn_attachment_name: str,
                 vpn_connection_id: str):
        """
        :param Sequence['GetGatewayVpnAttachmentsAttachmentBgpConfigArgs'] bgp_configs: The configurations of the BGP routing protocol.
        :param str connection_status: The status of the IPsec-VPN connection.
        :param str create_time: The creation time of the resource.
        :param str customer_gateway_id: The ID of the customer gateway.
        :param bool effect_immediately: Indicates whether IPsec-VPN negotiations are initiated immediately. Valid values.
        :param Sequence['GetGatewayVpnAttachmentsAttachmentHealthCheckConfigArgs'] health_check_configs: The health check configurations.
        :param str id: The ID of the Vpn Attachment.
        :param Sequence['GetGatewayVpnAttachmentsAttachmentIkeConfigArgs'] ike_configs: Configuration negotiated in the second stage.
        :param str internet_ip: The internet ip of the resource. The cen.TransitRouterVpnAttachment resource will not have a value until after it is created.
        :param Sequence['GetGatewayVpnAttachmentsAttachmentIpsecConfigArgs'] ipsec_configs: The configuration of Phase 2 negotiations.
        :param str local_subnet: The CIDR block of the virtual private cloud (VPC).
        :param str network_type: The network type.
        :param str remote_subnet: The CIDR block of the on-premises data center.
        :param str status: The status of the resource.
        :param str vpn_attachment_name: The name of the IPsec-VPN connection.
        :param str vpn_connection_id: The first ID of the resource.
        """
        pulumi.set(__self__, "bgp_configs", bgp_configs)
        pulumi.set(__self__, "connection_status", connection_status)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "customer_gateway_id", customer_gateway_id)
        pulumi.set(__self__, "effect_immediately", effect_immediately)
        pulumi.set(__self__, "health_check_configs", health_check_configs)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "ike_configs", ike_configs)
        pulumi.set(__self__, "internet_ip", internet_ip)
        pulumi.set(__self__, "ipsec_configs", ipsec_configs)
        pulumi.set(__self__, "local_subnet", local_subnet)
        pulumi.set(__self__, "network_type", network_type)
        pulumi.set(__self__, "remote_subnet", remote_subnet)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpn_attachment_name", vpn_attachment_name)
        pulumi.set(__self__, "vpn_connection_id", vpn_connection_id)

    @property
    @pulumi.getter(name="bgpConfigs")
    def bgp_configs(self) -> Sequence['outputs.GetGatewayVpnAttachmentsAttachmentBgpConfigResult']:
        """
        The configurations of the BGP routing protocol.
        """
        return pulumi.get(self, "bgp_configs")

    @property
    @pulumi.getter(name="connectionStatus")
    def connection_status(self) -> str:
        """
        The status of the IPsec-VPN connection.
        """
        return pulumi.get(self, "connection_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(name="customerGatewayId")
    def customer_gateway_id(self) -> str:
        """
        The ID of the customer gateway.
        """
        return pulumi.get(self, "customer_gateway_id")

    @property
    @pulumi.getter(name="effectImmediately")
    def effect_immediately(self) -> bool:
        """
        Indicates whether IPsec-VPN negotiations are initiated immediately. Valid values.
        """
        return pulumi.get(self, "effect_immediately")

    @property
    @pulumi.getter(name="healthCheckConfigs")
    def health_check_configs(self) -> Sequence['outputs.GetGatewayVpnAttachmentsAttachmentHealthCheckConfigResult']:
        """
        The health check configurations.
        """
        return pulumi.get(self, "health_check_configs")

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

    @property
    @pulumi.getter(name="ikeConfigs")
    def ike_configs(self) -> Sequence['outputs.GetGatewayVpnAttachmentsAttachmentIkeConfigResult']:
        """
        Configuration negotiated in the second stage.
        """
        return pulumi.get(self, "ike_configs")

    @property
    @pulumi.getter(name="internetIp")
    def internet_ip(self) -> str:
        """
        The internet ip of the resource. The cen.TransitRouterVpnAttachment resource will not have a value until after it is created.
        """
        return pulumi.get(self, "internet_ip")

    @property
    @pulumi.getter(name="ipsecConfigs")
    def ipsec_configs(self) -> Sequence['outputs.GetGatewayVpnAttachmentsAttachmentIpsecConfigResult']:
        """
        The configuration of Phase 2 negotiations.
        """
        return pulumi.get(self, "ipsec_configs")

    @property
    @pulumi.getter(name="localSubnet")
    def local_subnet(self) -> str:
        """
        The CIDR block of the virtual private cloud (VPC).
        """
        return pulumi.get(self, "local_subnet")

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> str:
        """
        The network type.
        """
        return pulumi.get(self, "network_type")

    @property
    @pulumi.getter(name="remoteSubnet")
    def remote_subnet(self) -> str:
        """
        The CIDR block of the on-premises data center.
        """
        return pulumi.get(self, "remote_subnet")

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

    @property
    @pulumi.getter(name="vpnAttachmentName")
    def vpn_attachment_name(self) -> str:
        """
        The name of the IPsec-VPN connection.
        """
        return pulumi.get(self, "vpn_attachment_name")

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


@pulumi.output_type
class GetGatewayVpnAttachmentsAttachmentBgpConfigResult(dict):
    def __init__(__self__, *,
                 local_asn: str,
                 local_bgp_ip: str,
                 status: str,
                 tunnel_cidr: str):
        """
        :param str local_asn: The ASN on the Alibaba Cloud side.
        :param str local_bgp_ip: The BGP IP address on the Alibaba Cloud side.
        :param str status: The negotiation status of the BGP routing protocol.
        :param str tunnel_cidr: The CIDR block of the IPsec tunnel. The CIDR block belongs to 169.254.0.0/16. The mask of the CIDR block is 30 bits in length.
        """
        pulumi.set(__self__, "local_asn", local_asn)
        pulumi.set(__self__, "local_bgp_ip", local_bgp_ip)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tunnel_cidr", tunnel_cidr)

    @property
    @pulumi.getter(name="localAsn")
    def local_asn(self) -> str:
        """
        The ASN on the Alibaba Cloud side.
        """
        return pulumi.get(self, "local_asn")

    @property
    @pulumi.getter(name="localBgpIp")
    def local_bgp_ip(self) -> str:
        """
        The BGP IP address on the Alibaba Cloud side.
        """
        return pulumi.get(self, "local_bgp_ip")

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

    @property
    @pulumi.getter(name="tunnelCidr")
    def tunnel_cidr(self) -> str:
        """
        The CIDR block of the IPsec tunnel. The CIDR block belongs to 169.254.0.0/16. The mask of the CIDR block is 30 bits in length.
        """
        return pulumi.get(self, "tunnel_cidr")


@pulumi.output_type
class GetGatewayVpnAttachmentsAttachmentHealthCheckConfigResult(dict):
    def __init__(__self__, *,
                 dip: str,
                 enable: bool,
                 interval: int,
                 policy: str,
                 retry: int,
                 sip: str,
                 status: str):
        """
        :param str dip: The destination IP address.
        :param bool enable: Specifies whether to enable health checks.
        :param int interval: The interval between two consecutive health checks. Unit: seconds.
        :param str policy: Whether to revoke the published route when the health check fails.
        :param int retry: The maximum number of health check retries.
        :param str sip: The source IP address.
        :param str status: The status of the health check.
        """
        pulumi.set(__self__, "dip", dip)
        pulumi.set(__self__, "enable", enable)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "policy", policy)
        pulumi.set(__self__, "retry", retry)
        pulumi.set(__self__, "sip", sip)
        pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    def dip(self) -> str:
        """
        The destination IP address.
        """
        return pulumi.get(self, "dip")

    @property
    @pulumi.getter
    def enable(self) -> bool:
        """
        Specifies whether to enable health checks.
        """
        return pulumi.get(self, "enable")

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

    @property
    @pulumi.getter
    def policy(self) -> str:
        """
        Whether to revoke the published route when the health check fails.
        """
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def retry(self) -> int:
        """
        The maximum number of health check retries.
        """
        return pulumi.get(self, "retry")

    @property
    @pulumi.getter
    def sip(self) -> str:
        """
        The source IP address.
        """
        return pulumi.get(self, "sip")

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


@pulumi.output_type
class GetGatewayVpnAttachmentsAttachmentIkeConfigResult(dict):
    def __init__(__self__, *,
                 ike_auth_alg: str,
                 ike_enc_alg: str,
                 ike_lifetime: str,
                 ike_mode: str,
                 ike_pfs: str,
                 ike_version: str,
                 local_id: str,
                 psk: str,
                 remote_id: str):
        """
        :param str ike_auth_alg: The IKE authentication algorithm.
        :param str ike_enc_alg: The IKE encryption algorithm.
        :param str ike_lifetime: The IKE lifetime. Unit: seconds.
        :param str ike_mode: The IKE negotiation mode.
        :param str ike_pfs: The DH group.
        :param str ike_version: The version of the IKE protocol.
        :param str local_id: The local ID, which supports the FQDN and IP formats. The current VPN gateway IP address is selected by default. The cen.TransitRouterVpnAttachment resource will not have a value until after it is created.
        :param str psk: The pre-shared key.
        :param str remote_id: The identifier of the peer. The default value is the IP address of the VPN gateway. The value can be a fully qualified domain name (FQDN) or an IP address.
        """
        pulumi.set(__self__, "ike_auth_alg", ike_auth_alg)
        pulumi.set(__self__, "ike_enc_alg", ike_enc_alg)
        pulumi.set(__self__, "ike_lifetime", ike_lifetime)
        pulumi.set(__self__, "ike_mode", ike_mode)
        pulumi.set(__self__, "ike_pfs", ike_pfs)
        pulumi.set(__self__, "ike_version", ike_version)
        pulumi.set(__self__, "local_id", local_id)
        pulumi.set(__self__, "psk", psk)
        pulumi.set(__self__, "remote_id", remote_id)

    @property
    @pulumi.getter(name="ikeAuthAlg")
    def ike_auth_alg(self) -> str:
        """
        The IKE authentication algorithm.
        """
        return pulumi.get(self, "ike_auth_alg")

    @property
    @pulumi.getter(name="ikeEncAlg")
    def ike_enc_alg(self) -> str:
        """
        The IKE encryption algorithm.
        """
        return pulumi.get(self, "ike_enc_alg")

    @property
    @pulumi.getter(name="ikeLifetime")
    def ike_lifetime(self) -> str:
        """
        The IKE lifetime. Unit: seconds.
        """
        return pulumi.get(self, "ike_lifetime")

    @property
    @pulumi.getter(name="ikeMode")
    def ike_mode(self) -> str:
        """
        The IKE negotiation mode.
        """
        return pulumi.get(self, "ike_mode")

    @property
    @pulumi.getter(name="ikePfs")
    def ike_pfs(self) -> str:
        """
        The DH group.
        """
        return pulumi.get(self, "ike_pfs")

    @property
    @pulumi.getter(name="ikeVersion")
    def ike_version(self) -> str:
        """
        The version of the IKE protocol.
        """
        return pulumi.get(self, "ike_version")

    @property
    @pulumi.getter(name="localId")
    def local_id(self) -> str:
        """
        The local ID, which supports the FQDN and IP formats. The current VPN gateway IP address is selected by default. The cen.TransitRouterVpnAttachment resource will not have a value until after it is created.
        """
        return pulumi.get(self, "local_id")

    @property
    @pulumi.getter
    def psk(self) -> str:
        """
        The pre-shared key.
        """
        return pulumi.get(self, "psk")

    @property
    @pulumi.getter(name="remoteId")
    def remote_id(self) -> str:
        """
        The identifier of the peer. The default value is the IP address of the VPN gateway. The value can be a fully qualified domain name (FQDN) or an IP address.
        """
        return pulumi.get(self, "remote_id")


@pulumi.output_type
class GetGatewayVpnAttachmentsAttachmentIpsecConfigResult(dict):
    def __init__(__self__, *,
                 ipsec_auth_alg: str,
                 ipsec_enc_alg: str,
                 ipsec_lifetime: str,
                 ipsec_pfs: str):
        """
        :param str ipsec_auth_alg: The IPsec authentication algorithm.
        :param str ipsec_enc_alg: The IPsec encryption algorithm.
        :param str ipsec_lifetime: The IPsec lifetime. Unit: seconds.
        :param str ipsec_pfs: The DH group.
        """
        pulumi.set(__self__, "ipsec_auth_alg", ipsec_auth_alg)
        pulumi.set(__self__, "ipsec_enc_alg", ipsec_enc_alg)
        pulumi.set(__self__, "ipsec_lifetime", ipsec_lifetime)
        pulumi.set(__self__, "ipsec_pfs", ipsec_pfs)

    @property
    @pulumi.getter(name="ipsecAuthAlg")
    def ipsec_auth_alg(self) -> str:
        """
        The IPsec authentication algorithm.
        """
        return pulumi.get(self, "ipsec_auth_alg")

    @property
    @pulumi.getter(name="ipsecEncAlg")
    def ipsec_enc_alg(self) -> str:
        """
        The IPsec encryption algorithm.
        """
        return pulumi.get(self, "ipsec_enc_alg")

    @property
    @pulumi.getter(name="ipsecLifetime")
    def ipsec_lifetime(self) -> str:
        """
        The IPsec lifetime. Unit: seconds.
        """
        return pulumi.get(self, "ipsec_lifetime")

    @property
    @pulumi.getter(name="ipsecPfs")
    def ipsec_pfs(self) -> str:
        """
        The DH group.
        """
        return pulumi.get(self, "ipsec_pfs")


@pulumi.output_type
class GetGatewayZonesZoneResult(dict):
    def __init__(__self__, *,
                 zone_id: str,
                 zone_name: str):
        """
        :param str zone_id: The zone ID.
        :param str zone_name: The zone name.
        """
        pulumi.set(__self__, "zone_id", zone_id)
        pulumi.set(__self__, "zone_name", zone_name)

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

    @property
    @pulumi.getter(name="zoneName")
    def zone_name(self) -> str:
        """
        The zone name.
        """
        return pulumi.get(self, "zone_name")


@pulumi.output_type
class GetGatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 auto_propagate: str,
                 business_status: str,
                 create_time: str,
                 description: str,
                 disaster_recovery_internet_ip: str,
                 disaster_recovery_vswitch_id: str,
                 enable_ipsec: str,
                 enable_ssl: str,
                 end_time: str,
                 id: str,
                 instance_charge_type: str,
                 internet_ip: str,
                 name: str,
                 network_type: str,
                 resource_group_id: str,
                 specification: str,
                 ssl_connections: int,
                 ssl_vpn_internet_ip: str,
                 status: str,
                 tags: Mapping[str, str],
                 vpc_id: str,
                 vpn_type: str,
                 vswitch_id: str):
        """
        :param str auto_propagate: Whether to automatically propagate BGP routes to the VPC. Valid values: `true`, `false`.
        :param str business_status: Limit search to specific business status - valid value is "Normal", "FinancialLocked".
        :param str create_time: The creation time of the VPN gateway.
        :param str description: The description of the VPN
        :param str disaster_recovery_internet_ip: The backup public IP address of the VPN gateway. The second IP address assigned by the system to create an IPsec-VPN connection. This parameter is returned only when the VPN gateway supports the dual-tunnel mode.
        :param str disaster_recovery_vswitch_id: - The ID of the backup vSwitch to which the VPN gateway is attached.
        :param str enable_ipsec: Indicates whether the IPsec-VPN feature is enabled.
        :param str enable_ssl: Whether the ssl function is enabled.
        :param str end_time: The expiration time of the VPN gateway.
        :param str id: ID of the VPN.
        :param str instance_charge_type: The charge type of the VPN gateway.
        :param str internet_ip: The internet ip of the VPN.
        :param str name: The name of the VPN.
        :param str network_type: The network type of the VPN gateway.
        :param str resource_group_id: The ID of the resource group.
        :param str specification: The Specification of the VPN
        :param int ssl_connections: Total count of ssl vpn connections.
        :param str ssl_vpn_internet_ip: The IP address of the SSL-VPN connection. This parameter is returned only when the VPN gateway is a public VPN gateway and supports only the single-tunnel mode. In addition, the VPN gateway must have the SSL-VPN feature enabled.
        :param str status: Limit search to specific status - valid value is "Init", "Provisioning", "Active", "Updating", "Deleting".
        :param Mapping[str, str] tags: The Tag of.
        :param str vpc_id: Use the VPC ID as the search key.
        :param str vpn_type: - The VPN gateway type. Value:  Normal (default): Normal type. NationalStandard: National Secret type.
        :param str vswitch_id: - The ID of the vSwitch to which the VPN gateway is attached.
        """
        pulumi.set(__self__, "auto_propagate", auto_propagate)
        pulumi.set(__self__, "business_status", business_status)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "disaster_recovery_internet_ip", disaster_recovery_internet_ip)
        pulumi.set(__self__, "disaster_recovery_vswitch_id", disaster_recovery_vswitch_id)
        pulumi.set(__self__, "enable_ipsec", enable_ipsec)
        pulumi.set(__self__, "enable_ssl", enable_ssl)
        pulumi.set(__self__, "end_time", end_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "instance_charge_type", instance_charge_type)
        pulumi.set(__self__, "internet_ip", internet_ip)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_type", network_type)
        pulumi.set(__self__, "resource_group_id", resource_group_id)
        pulumi.set(__self__, "specification", specification)
        pulumi.set(__self__, "ssl_connections", ssl_connections)
        pulumi.set(__self__, "ssl_vpn_internet_ip", ssl_vpn_internet_ip)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vpn_type", vpn_type)
        pulumi.set(__self__, "vswitch_id", vswitch_id)

    @property
    @pulumi.getter(name="autoPropagate")
    def auto_propagate(self) -> str:
        """
        Whether to automatically propagate BGP routes to the VPC. Valid values: `true`, `false`.
        """
        return pulumi.get(self, "auto_propagate")

    @property
    @pulumi.getter(name="businessStatus")
    def business_status(self) -> str:
        """
        Limit search to specific business status - valid value is "Normal", "FinancialLocked".
        """
        return pulumi.get(self, "business_status")

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

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

    @property
    @pulumi.getter(name="disasterRecoveryInternetIp")
    def disaster_recovery_internet_ip(self) -> str:
        """
        The backup public IP address of the VPN gateway. The second IP address assigned by the system to create an IPsec-VPN connection. This parameter is returned only when the VPN gateway supports the dual-tunnel mode.
        """
        return pulumi.get(self, "disaster_recovery_internet_ip")

    @property
    @pulumi.getter(name="disasterRecoveryVswitchId")
    def disaster_recovery_vswitch_id(self) -> str:
        """
        - The ID of the backup vSwitch to which the VPN gateway is attached.
        """
        return pulumi.get(self, "disaster_recovery_vswitch_id")

    @property
    @pulumi.getter(name="enableIpsec")
    def enable_ipsec(self) -> str:
        """
        Indicates whether the IPsec-VPN feature is enabled.
        """
        return pulumi.get(self, "enable_ipsec")

    @property
    @pulumi.getter(name="enableSsl")
    def enable_ssl(self) -> str:
        """
        Whether the ssl function is enabled.
        """
        return pulumi.get(self, "enable_ssl")

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

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

    @property
    @pulumi.getter(name="instanceChargeType")
    def instance_charge_type(self) -> str:
        """
        The charge type of the VPN gateway.
        """
        return pulumi.get(self, "instance_charge_type")

    @property
    @pulumi.getter(name="internetIp")
    def internet_ip(self) -> str:
        """
        The internet ip of the VPN.
        """
        return pulumi.get(self, "internet_ip")

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

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> str:
        """
        The network type of the VPN gateway.
        """
        return pulumi.get(self, "network_type")

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

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

    @property
    @pulumi.getter(name="sslConnections")
    def ssl_connections(self) -> int:
        """
        Total count of ssl vpn connections.
        """
        return pulumi.get(self, "ssl_connections")

    @property
    @pulumi.getter(name="sslVpnInternetIp")
    def ssl_vpn_internet_ip(self) -> str:
        """
        The IP address of the SSL-VPN connection. This parameter is returned only when the VPN gateway is a public VPN gateway and supports only the single-tunnel mode. In addition, the VPN gateway must have the SSL-VPN feature enabled.
        """
        return pulumi.get(self, "ssl_vpn_internet_ip")

    @property
    @pulumi.getter
    def status(self) -> str:
        """
        Limit search to specific status - valid value is "Init", "Provisioning", "Active", "Updating", "Deleting".
        """
        return pulumi.get(self, "status")

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

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

    @property
    @pulumi.getter(name="vpnType")
    def vpn_type(self) -> str:
        """
        - The VPN gateway type. Value:  Normal (default): Normal type. NationalStandard: National Secret type.
        """
        return pulumi.get(self, "vpn_type")

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


