# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'ConnectionIkeConfig',
    'ConnectionIpsecConfig',
    'GetConnectionsConnectionResult',
    'GetConnectionsConnectionIkeConfigResult',
    'GetConnectionsConnectionIpsecConfigResult',
    'GetCustomerGatewaysGatewayResult',
    'GetGatewaysGatewayResult',
]

@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 of phase-one negotiation. Valid value: md5 | sha1 | sha256 | sha384 | sha512 |. Default value: sha1
        :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_local_id: The identification of the VPN gateway.
        :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_remote_id: The identification of the customer gateway.
        :param str ike_version: The version of the IKE protocol. Valid value: ikev1 | ikev2. Default value: ikev1
        :param str psk: Used for authentication between the IPsec VPN gateway and the customer 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_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 of phase-one negotiation. Valid value: md5 | sha1 | sha256 | sha384 | sha512 |. 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 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="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]:
        """
        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="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]:
        """
        The version of the IKE protocol. Valid value: ikev1 | ikev2. Default value: ikev1
        """
        return pulumi.get(self, "ike_version")

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


@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 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 GetConnectionsConnectionResult(dict):
    def __init__(__self__, *,
                 create_time: str,
                 customer_gateway_id: str,
                 effect_immediately: bool,
                 id: str,
                 local_subnet: str,
                 name: str,
                 remote_subnet: str,
                 status: str,
                 vpn_gateway_id: str,
                 ike_configs: Optional[Sequence['outputs.GetConnectionsConnectionIkeConfigResult']] = None,
                 ipsec_configs: Optional[Sequence['outputs.GetConnectionsConnectionIpsecConfigResult']] = None):
        """
        :param str customer_gateway_id: Use the VPN customer gateway ID as the search key.
        :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 status of the VPN connection, valid value:ike_sa_not_established, ike_sa_established, ipsec_sa_not_established, ipsec_sa_established.
        :param str vpn_gateway_id: Use the VPN gateway ID as the search key.
        :param Sequence['GetConnectionsConnectionIkeConfigArgs'] ike_configs: The configurations of phase-one negotiation.
        :param Sequence['GetConnectionsConnectionIpsecConfigArgs'] ipsec_configs: The configurations of phase-two negotiation.
        """
        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__, "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__, "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)

    @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
    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 status of the VPN connection, valid value:ike_sa_not_established, ike_sa_established, ipsec_sa_not_established, ipsec_sa_established.
        """
        return pulumi.get(self, "status")

    @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 configurations of phase-one negotiation.
        """
        return pulumi.get(self, "ike_configs")

    @property
    @pulumi.getter(name="ipsecConfigs")
    def ipsec_configs(self) -> Optional[Sequence['outputs.GetConnectionsConnectionIpsecConfigResult']]:
        """
        The configurations of phase-two negotiation.
        """
        return pulumi.get(self, "ipsec_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: The authentication algorithm of phase-one negotiation.
        :param str ike_enc_alg: The encryption algorithm of phase-one negotiation.
        :param int ike_lifetime: The SA lifecycle as the result of phase-one negotiation.
        :param str ike_local_id: The identification of the VPN gateway.
        :param str ike_mode: The negotiation mode of IKE phase-one.
        :param str ike_pfs: The Diffie-Hellman key exchange algorithm used by phase-one negotiation.
        :param str ike_remote_id: The identification of the customer gateway.
        :param str ike_version: The version of the IKE protocol.
        :param str psk: Used for authentication between the IPsec VPN gateway and the customer 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_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 of phase-one negotiation.
        """
        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.
        """
        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.
        """
        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]:
        """
        The negotiation mode of IKE phase-one.
        """
        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.
        """
        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]:
        """
        The version of the IKE protocol.
        """
        return pulumi.get(self, "ike_version")

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


@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: The authentication algorithm of phase-two negotiation.
        :param str ipsec_enc_alg: The encryption algorithm of phase-two negotiation.
        :param int ipsec_lifetime: The SA lifecycle as the result of phase-two negotiation.
        :param str ipsec_pfs: The Diffie-Hellman key exchange algorithm used by phase-two negotiation.
        """
        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.
        """
        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.
        """
        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.
        """
        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.
        """
        return pulumi.get(self, "ipsec_pfs")


@pulumi.output_type
class GetCustomerGatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 create_time: str,
                 description: str,
                 id: str,
                 ip_address: str,
                 name: str):
        """
        :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__, "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(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 GetGatewaysGatewayResult(dict):
    def __init__(__self__, *,
                 business_status: str,
                 create_time: str,
                 description: str,
                 enable_ipsec: str,
                 enable_ssl: str,
                 end_time: str,
                 id: str,
                 instance_charge_type: str,
                 internet_ip: str,
                 name: str,
                 specification: str,
                 ssl_connections: int,
                 status: str,
                 vpc_id: str):
        """
        :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 enable_ipsec: Whether the ipsec function 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 specification: The Specification of the VPN
        :param int ssl_connections: Total count of ssl vpn connections.
        :param str status: Limit search to specific status - valid value is "Init", "Provisioning", "Active", "Updating", "Deleting".
        :param str vpc_id: Use the VPC ID as the search key.
        """
        pulumi.set(__self__, "business_status", business_status)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "description", description)
        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__, "specification", specification)
        pulumi.set(__self__, "ssl_connections", ssl_connections)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "vpc_id", vpc_id)

    @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="enableIpsec")
    def enable_ipsec(self) -> str:
        """
        Whether the ipsec function 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
    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
    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(name="vpcId")
    def vpc_id(self) -> str:
        """
        Use the VPC ID as the search key.
        """
        return pulumi.get(self, "vpc_id")


