{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.EC2.Types.VpnConnectionOptions
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.EC2.Types.VpnConnectionOptions where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.TunnelInsideIpVersion
import Amazonka.EC2.Types.TunnelOption
import qualified Amazonka.Prelude as Prelude

-- | Describes VPN connection options.
--
-- /See:/ 'newVpnConnectionOptions' smart constructor.
data VpnConnectionOptions = VpnConnectionOptions'
  { -- | Indicates whether acceleration is enabled for the VPN connection.
    VpnConnectionOptions -> Maybe Bool
enableAcceleration :: Prelude.Maybe Prelude.Bool,
    -- | The IPv4 CIDR on the customer gateway (on-premises) side of the VPN
    -- connection.
    VpnConnectionOptions -> Maybe Text
localIpv4NetworkCidr :: Prelude.Maybe Prelude.Text,
    -- | The IPv6 CIDR on the customer gateway (on-premises) side of the VPN
    -- connection.
    VpnConnectionOptions -> Maybe Text
localIpv6NetworkCidr :: Prelude.Maybe Prelude.Text,
    -- | The type of IPv4 address assigned to the outside interface of the
    -- customer gateway.
    --
    -- Valid values: @PrivateIpv4@ | @PublicIpv4@
    --
    -- Default: @PublicIpv4@
    VpnConnectionOptions -> Maybe Text
outsideIpAddressType :: Prelude.Maybe Prelude.Text,
    -- | The IPv4 CIDR on the Amazon Web Services side of the VPN connection.
    VpnConnectionOptions -> Maybe Text
remoteIpv4NetworkCidr :: Prelude.Maybe Prelude.Text,
    -- | The IPv6 CIDR on the Amazon Web Services side of the VPN connection.
    VpnConnectionOptions -> Maybe Text
remoteIpv6NetworkCidr :: Prelude.Maybe Prelude.Text,
    -- | Indicates whether the VPN connection uses static routes only. Static
    -- routes must be used for devices that don\'t support BGP.
    VpnConnectionOptions -> Maybe Bool
staticRoutesOnly :: Prelude.Maybe Prelude.Bool,
    -- | The transit gateway attachment ID in use for the VPN tunnel.
    VpnConnectionOptions -> Maybe Text
transportTransitGatewayAttachmentId :: Prelude.Maybe Prelude.Text,
    -- | Indicates whether the VPN tunnels process IPv4 or IPv6 traffic.
    VpnConnectionOptions -> Maybe TunnelInsideIpVersion
tunnelInsideIpVersion :: Prelude.Maybe TunnelInsideIpVersion,
    -- | Indicates the VPN tunnel options.
    VpnConnectionOptions -> Maybe [TunnelOption]
tunnelOptions :: Prelude.Maybe [TunnelOption]
  }
  deriving (VpnConnectionOptions -> VpnConnectionOptions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VpnConnectionOptions -> VpnConnectionOptions -> Bool
$c/= :: VpnConnectionOptions -> VpnConnectionOptions -> Bool
== :: VpnConnectionOptions -> VpnConnectionOptions -> Bool
$c== :: VpnConnectionOptions -> VpnConnectionOptions -> Bool
Prelude.Eq, ReadPrec [VpnConnectionOptions]
ReadPrec VpnConnectionOptions
Int -> ReadS VpnConnectionOptions
ReadS [VpnConnectionOptions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VpnConnectionOptions]
$creadListPrec :: ReadPrec [VpnConnectionOptions]
readPrec :: ReadPrec VpnConnectionOptions
$creadPrec :: ReadPrec VpnConnectionOptions
readList :: ReadS [VpnConnectionOptions]
$creadList :: ReadS [VpnConnectionOptions]
readsPrec :: Int -> ReadS VpnConnectionOptions
$creadsPrec :: Int -> ReadS VpnConnectionOptions
Prelude.Read, Int -> VpnConnectionOptions -> ShowS
[VpnConnectionOptions] -> ShowS
VpnConnectionOptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VpnConnectionOptions] -> ShowS
$cshowList :: [VpnConnectionOptions] -> ShowS
show :: VpnConnectionOptions -> String
$cshow :: VpnConnectionOptions -> String
showsPrec :: Int -> VpnConnectionOptions -> ShowS
$cshowsPrec :: Int -> VpnConnectionOptions -> ShowS
Prelude.Show, forall x. Rep VpnConnectionOptions x -> VpnConnectionOptions
forall x. VpnConnectionOptions -> Rep VpnConnectionOptions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VpnConnectionOptions x -> VpnConnectionOptions
$cfrom :: forall x. VpnConnectionOptions -> Rep VpnConnectionOptions x
Prelude.Generic)

-- |
-- Create a value of 'VpnConnectionOptions' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'enableAcceleration', 'vpnConnectionOptions_enableAcceleration' - Indicates whether acceleration is enabled for the VPN connection.
--
-- 'localIpv4NetworkCidr', 'vpnConnectionOptions_localIpv4NetworkCidr' - The IPv4 CIDR on the customer gateway (on-premises) side of the VPN
-- connection.
--
-- 'localIpv6NetworkCidr', 'vpnConnectionOptions_localIpv6NetworkCidr' - The IPv6 CIDR on the customer gateway (on-premises) side of the VPN
-- connection.
--
-- 'outsideIpAddressType', 'vpnConnectionOptions_outsideIpAddressType' - The type of IPv4 address assigned to the outside interface of the
-- customer gateway.
--
-- Valid values: @PrivateIpv4@ | @PublicIpv4@
--
-- Default: @PublicIpv4@
--
-- 'remoteIpv4NetworkCidr', 'vpnConnectionOptions_remoteIpv4NetworkCidr' - The IPv4 CIDR on the Amazon Web Services side of the VPN connection.
--
-- 'remoteIpv6NetworkCidr', 'vpnConnectionOptions_remoteIpv6NetworkCidr' - The IPv6 CIDR on the Amazon Web Services side of the VPN connection.
--
-- 'staticRoutesOnly', 'vpnConnectionOptions_staticRoutesOnly' - Indicates whether the VPN connection uses static routes only. Static
-- routes must be used for devices that don\'t support BGP.
--
-- 'transportTransitGatewayAttachmentId', 'vpnConnectionOptions_transportTransitGatewayAttachmentId' - The transit gateway attachment ID in use for the VPN tunnel.
--
-- 'tunnelInsideIpVersion', 'vpnConnectionOptions_tunnelInsideIpVersion' - Indicates whether the VPN tunnels process IPv4 or IPv6 traffic.
--
-- 'tunnelOptions', 'vpnConnectionOptions_tunnelOptions' - Indicates the VPN tunnel options.
newVpnConnectionOptions ::
  VpnConnectionOptions
newVpnConnectionOptions :: VpnConnectionOptions
newVpnConnectionOptions =
  VpnConnectionOptions'
    { $sel:enableAcceleration:VpnConnectionOptions' :: Maybe Bool
enableAcceleration =
        forall a. Maybe a
Prelude.Nothing,
      $sel:localIpv4NetworkCidr:VpnConnectionOptions' :: Maybe Text
localIpv4NetworkCidr = forall a. Maybe a
Prelude.Nothing,
      $sel:localIpv6NetworkCidr:VpnConnectionOptions' :: Maybe Text
localIpv6NetworkCidr = forall a. Maybe a
Prelude.Nothing,
      $sel:outsideIpAddressType:VpnConnectionOptions' :: Maybe Text
outsideIpAddressType = forall a. Maybe a
Prelude.Nothing,
      $sel:remoteIpv4NetworkCidr:VpnConnectionOptions' :: Maybe Text
remoteIpv4NetworkCidr = forall a. Maybe a
Prelude.Nothing,
      $sel:remoteIpv6NetworkCidr:VpnConnectionOptions' :: Maybe Text
remoteIpv6NetworkCidr = forall a. Maybe a
Prelude.Nothing,
      $sel:staticRoutesOnly:VpnConnectionOptions' :: Maybe Bool
staticRoutesOnly = forall a. Maybe a
Prelude.Nothing,
      $sel:transportTransitGatewayAttachmentId:VpnConnectionOptions' :: Maybe Text
transportTransitGatewayAttachmentId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:tunnelInsideIpVersion:VpnConnectionOptions' :: Maybe TunnelInsideIpVersion
tunnelInsideIpVersion = forall a. Maybe a
Prelude.Nothing,
      $sel:tunnelOptions:VpnConnectionOptions' :: Maybe [TunnelOption]
tunnelOptions = forall a. Maybe a
Prelude.Nothing
    }

-- | Indicates whether acceleration is enabled for the VPN connection.
vpnConnectionOptions_enableAcceleration :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Bool)
vpnConnectionOptions_enableAcceleration :: Lens' VpnConnectionOptions (Maybe Bool)
vpnConnectionOptions_enableAcceleration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Bool
enableAcceleration :: Maybe Bool
$sel:enableAcceleration:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Bool
enableAcceleration} -> Maybe Bool
enableAcceleration) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Bool
a -> VpnConnectionOptions
s {$sel:enableAcceleration:VpnConnectionOptions' :: Maybe Bool
enableAcceleration = Maybe Bool
a} :: VpnConnectionOptions)

-- | The IPv4 CIDR on the customer gateway (on-premises) side of the VPN
-- connection.
vpnConnectionOptions_localIpv4NetworkCidr :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Text)
vpnConnectionOptions_localIpv4NetworkCidr :: Lens' VpnConnectionOptions (Maybe Text)
vpnConnectionOptions_localIpv4NetworkCidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Text
localIpv4NetworkCidr :: Maybe Text
$sel:localIpv4NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
localIpv4NetworkCidr} -> Maybe Text
localIpv4NetworkCidr) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Text
a -> VpnConnectionOptions
s {$sel:localIpv4NetworkCidr:VpnConnectionOptions' :: Maybe Text
localIpv4NetworkCidr = Maybe Text
a} :: VpnConnectionOptions)

-- | The IPv6 CIDR on the customer gateway (on-premises) side of the VPN
-- connection.
vpnConnectionOptions_localIpv6NetworkCidr :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Text)
vpnConnectionOptions_localIpv6NetworkCidr :: Lens' VpnConnectionOptions (Maybe Text)
vpnConnectionOptions_localIpv6NetworkCidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Text
localIpv6NetworkCidr :: Maybe Text
$sel:localIpv6NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
localIpv6NetworkCidr} -> Maybe Text
localIpv6NetworkCidr) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Text
a -> VpnConnectionOptions
s {$sel:localIpv6NetworkCidr:VpnConnectionOptions' :: Maybe Text
localIpv6NetworkCidr = Maybe Text
a} :: VpnConnectionOptions)

-- | The type of IPv4 address assigned to the outside interface of the
-- customer gateway.
--
-- Valid values: @PrivateIpv4@ | @PublicIpv4@
--
-- Default: @PublicIpv4@
vpnConnectionOptions_outsideIpAddressType :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Text)
vpnConnectionOptions_outsideIpAddressType :: Lens' VpnConnectionOptions (Maybe Text)
vpnConnectionOptions_outsideIpAddressType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Text
outsideIpAddressType :: Maybe Text
$sel:outsideIpAddressType:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
outsideIpAddressType} -> Maybe Text
outsideIpAddressType) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Text
a -> VpnConnectionOptions
s {$sel:outsideIpAddressType:VpnConnectionOptions' :: Maybe Text
outsideIpAddressType = Maybe Text
a} :: VpnConnectionOptions)

-- | The IPv4 CIDR on the Amazon Web Services side of the VPN connection.
vpnConnectionOptions_remoteIpv4NetworkCidr :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Text)
vpnConnectionOptions_remoteIpv4NetworkCidr :: Lens' VpnConnectionOptions (Maybe Text)
vpnConnectionOptions_remoteIpv4NetworkCidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Text
remoteIpv4NetworkCidr :: Maybe Text
$sel:remoteIpv4NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
remoteIpv4NetworkCidr} -> Maybe Text
remoteIpv4NetworkCidr) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Text
a -> VpnConnectionOptions
s {$sel:remoteIpv4NetworkCidr:VpnConnectionOptions' :: Maybe Text
remoteIpv4NetworkCidr = Maybe Text
a} :: VpnConnectionOptions)

-- | The IPv6 CIDR on the Amazon Web Services side of the VPN connection.
vpnConnectionOptions_remoteIpv6NetworkCidr :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Text)
vpnConnectionOptions_remoteIpv6NetworkCidr :: Lens' VpnConnectionOptions (Maybe Text)
vpnConnectionOptions_remoteIpv6NetworkCidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Text
remoteIpv6NetworkCidr :: Maybe Text
$sel:remoteIpv6NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
remoteIpv6NetworkCidr} -> Maybe Text
remoteIpv6NetworkCidr) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Text
a -> VpnConnectionOptions
s {$sel:remoteIpv6NetworkCidr:VpnConnectionOptions' :: Maybe Text
remoteIpv6NetworkCidr = Maybe Text
a} :: VpnConnectionOptions)

-- | Indicates whether the VPN connection uses static routes only. Static
-- routes must be used for devices that don\'t support BGP.
vpnConnectionOptions_staticRoutesOnly :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Bool)
vpnConnectionOptions_staticRoutesOnly :: Lens' VpnConnectionOptions (Maybe Bool)
vpnConnectionOptions_staticRoutesOnly = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Bool
staticRoutesOnly :: Maybe Bool
$sel:staticRoutesOnly:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Bool
staticRoutesOnly} -> Maybe Bool
staticRoutesOnly) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Bool
a -> VpnConnectionOptions
s {$sel:staticRoutesOnly:VpnConnectionOptions' :: Maybe Bool
staticRoutesOnly = Maybe Bool
a} :: VpnConnectionOptions)

-- | The transit gateway attachment ID in use for the VPN tunnel.
vpnConnectionOptions_transportTransitGatewayAttachmentId :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe Prelude.Text)
vpnConnectionOptions_transportTransitGatewayAttachmentId :: Lens' VpnConnectionOptions (Maybe Text)
vpnConnectionOptions_transportTransitGatewayAttachmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe Text
transportTransitGatewayAttachmentId :: Maybe Text
$sel:transportTransitGatewayAttachmentId:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
transportTransitGatewayAttachmentId} -> Maybe Text
transportTransitGatewayAttachmentId) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe Text
a -> VpnConnectionOptions
s {$sel:transportTransitGatewayAttachmentId:VpnConnectionOptions' :: Maybe Text
transportTransitGatewayAttachmentId = Maybe Text
a} :: VpnConnectionOptions)

-- | Indicates whether the VPN tunnels process IPv4 or IPv6 traffic.
vpnConnectionOptions_tunnelInsideIpVersion :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe TunnelInsideIpVersion)
vpnConnectionOptions_tunnelInsideIpVersion :: Lens' VpnConnectionOptions (Maybe TunnelInsideIpVersion)
vpnConnectionOptions_tunnelInsideIpVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe TunnelInsideIpVersion
tunnelInsideIpVersion :: Maybe TunnelInsideIpVersion
$sel:tunnelInsideIpVersion:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe TunnelInsideIpVersion
tunnelInsideIpVersion} -> Maybe TunnelInsideIpVersion
tunnelInsideIpVersion) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe TunnelInsideIpVersion
a -> VpnConnectionOptions
s {$sel:tunnelInsideIpVersion:VpnConnectionOptions' :: Maybe TunnelInsideIpVersion
tunnelInsideIpVersion = Maybe TunnelInsideIpVersion
a} :: VpnConnectionOptions)

-- | Indicates the VPN tunnel options.
vpnConnectionOptions_tunnelOptions :: Lens.Lens' VpnConnectionOptions (Prelude.Maybe [TunnelOption])
vpnConnectionOptions_tunnelOptions :: Lens' VpnConnectionOptions (Maybe [TunnelOption])
vpnConnectionOptions_tunnelOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VpnConnectionOptions' {Maybe [TunnelOption]
tunnelOptions :: Maybe [TunnelOption]
$sel:tunnelOptions:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe [TunnelOption]
tunnelOptions} -> Maybe [TunnelOption]
tunnelOptions) (\s :: VpnConnectionOptions
s@VpnConnectionOptions' {} Maybe [TunnelOption]
a -> VpnConnectionOptions
s {$sel:tunnelOptions:VpnConnectionOptions' :: Maybe [TunnelOption]
tunnelOptions = Maybe [TunnelOption]
a} :: VpnConnectionOptions) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Data.FromXML VpnConnectionOptions where
  parseXML :: [Node] -> Either String VpnConnectionOptions
parseXML [Node]
x =
    Maybe Bool
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe Text
-> Maybe TunnelInsideIpVersion
-> Maybe [TunnelOption]
-> VpnConnectionOptions
VpnConnectionOptions'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"enableAcceleration")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"localIpv4NetworkCidr")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"localIpv6NetworkCidr")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"outsideIpAddressType")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"remoteIpv4NetworkCidr")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"remoteIpv6NetworkCidr")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"staticRoutesOnly")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"transportTransitGatewayAttachmentId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"tunnelInsideIpVersion")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"tunnelOptionSet"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )

instance Prelude.Hashable VpnConnectionOptions where
  hashWithSalt :: Int -> VpnConnectionOptions -> Int
hashWithSalt Int
_salt VpnConnectionOptions' {Maybe Bool
Maybe [TunnelOption]
Maybe Text
Maybe TunnelInsideIpVersion
tunnelOptions :: Maybe [TunnelOption]
tunnelInsideIpVersion :: Maybe TunnelInsideIpVersion
transportTransitGatewayAttachmentId :: Maybe Text
staticRoutesOnly :: Maybe Bool
remoteIpv6NetworkCidr :: Maybe Text
remoteIpv4NetworkCidr :: Maybe Text
outsideIpAddressType :: Maybe Text
localIpv6NetworkCidr :: Maybe Text
localIpv4NetworkCidr :: Maybe Text
enableAcceleration :: Maybe Bool
$sel:tunnelOptions:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe [TunnelOption]
$sel:tunnelInsideIpVersion:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe TunnelInsideIpVersion
$sel:transportTransitGatewayAttachmentId:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:staticRoutesOnly:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Bool
$sel:remoteIpv6NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:remoteIpv4NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:outsideIpAddressType:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:localIpv6NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:localIpv4NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:enableAcceleration:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
enableAcceleration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
localIpv4NetworkCidr
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
localIpv6NetworkCidr
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
outsideIpAddressType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
remoteIpv4NetworkCidr
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
remoteIpv6NetworkCidr
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
staticRoutesOnly
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
transportTransitGatewayAttachmentId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TunnelInsideIpVersion
tunnelInsideIpVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [TunnelOption]
tunnelOptions

instance Prelude.NFData VpnConnectionOptions where
  rnf :: VpnConnectionOptions -> ()
rnf VpnConnectionOptions' {Maybe Bool
Maybe [TunnelOption]
Maybe Text
Maybe TunnelInsideIpVersion
tunnelOptions :: Maybe [TunnelOption]
tunnelInsideIpVersion :: Maybe TunnelInsideIpVersion
transportTransitGatewayAttachmentId :: Maybe Text
staticRoutesOnly :: Maybe Bool
remoteIpv6NetworkCidr :: Maybe Text
remoteIpv4NetworkCidr :: Maybe Text
outsideIpAddressType :: Maybe Text
localIpv6NetworkCidr :: Maybe Text
localIpv4NetworkCidr :: Maybe Text
enableAcceleration :: Maybe Bool
$sel:tunnelOptions:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe [TunnelOption]
$sel:tunnelInsideIpVersion:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe TunnelInsideIpVersion
$sel:transportTransitGatewayAttachmentId:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:staticRoutesOnly:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Bool
$sel:remoteIpv6NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:remoteIpv4NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:outsideIpAddressType:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:localIpv6NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:localIpv4NetworkCidr:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Text
$sel:enableAcceleration:VpnConnectionOptions' :: VpnConnectionOptions -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
enableAcceleration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
localIpv4NetworkCidr
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
localIpv6NetworkCidr
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
outsideIpAddressType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
remoteIpv4NetworkCidr
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
remoteIpv6NetworkCidr
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
staticRoutesOnly
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
transportTransitGatewayAttachmentId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TunnelInsideIpVersion
tunnelInsideIpVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [TunnelOption]
tunnelOptions