{-# 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.TunnelOption
-- 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.TunnelOption 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.IKEVersionsListValue
import Amazonka.EC2.Types.Phase1DHGroupNumbersListValue
import Amazonka.EC2.Types.Phase1EncryptionAlgorithmsListValue
import Amazonka.EC2.Types.Phase1IntegrityAlgorithmsListValue
import Amazonka.EC2.Types.Phase2DHGroupNumbersListValue
import Amazonka.EC2.Types.Phase2EncryptionAlgorithmsListValue
import Amazonka.EC2.Types.Phase2IntegrityAlgorithmsListValue
import Amazonka.EC2.Types.VpnTunnelLogOptions
import qualified Amazonka.Prelude as Prelude

-- | The VPN tunnel options.
--
-- /See:/ 'newTunnelOption' smart constructor.
data TunnelOption = TunnelOption'
  { -- | The action to take after a DPD timeout occurs.
    TunnelOption -> Maybe Text
dpdTimeoutAction :: Prelude.Maybe Prelude.Text,
    -- | The number of seconds after which a DPD timeout occurs.
    TunnelOption -> Maybe Int
dpdTimeoutSeconds :: Prelude.Maybe Prelude.Int,
    -- | The IKE versions that are permitted for the VPN tunnel.
    TunnelOption -> Maybe [IKEVersionsListValue]
ikeVersions :: Prelude.Maybe [IKEVersionsListValue],
    -- | Options for logging VPN tunnel activity.
    TunnelOption -> Maybe VpnTunnelLogOptions
logOptions :: Prelude.Maybe VpnTunnelLogOptions,
    -- | The external IP address of the VPN tunnel.
    TunnelOption -> Maybe Text
outsideIpAddress :: Prelude.Maybe Prelude.Text,
    -- | The permitted Diffie-Hellman group numbers for the VPN tunnel for phase
    -- 1 IKE negotiations.
    TunnelOption -> Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers :: Prelude.Maybe [Phase1DHGroupNumbersListValue],
    -- | The permitted encryption algorithms for the VPN tunnel for phase 1 IKE
    -- negotiations.
    TunnelOption -> Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms :: Prelude.Maybe [Phase1EncryptionAlgorithmsListValue],
    -- | The permitted integrity algorithms for the VPN tunnel for phase 1 IKE
    -- negotiations.
    TunnelOption -> Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms :: Prelude.Maybe [Phase1IntegrityAlgorithmsListValue],
    -- | The lifetime for phase 1 of the IKE negotiation, in seconds.
    TunnelOption -> Maybe Int
phase1LifetimeSeconds :: Prelude.Maybe Prelude.Int,
    -- | The permitted Diffie-Hellman group numbers for the VPN tunnel for phase
    -- 2 IKE negotiations.
    TunnelOption -> Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers :: Prelude.Maybe [Phase2DHGroupNumbersListValue],
    -- | The permitted encryption algorithms for the VPN tunnel for phase 2 IKE
    -- negotiations.
    TunnelOption -> Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms :: Prelude.Maybe [Phase2EncryptionAlgorithmsListValue],
    -- | The permitted integrity algorithms for the VPN tunnel for phase 2 IKE
    -- negotiations.
    TunnelOption -> Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms :: Prelude.Maybe [Phase2IntegrityAlgorithmsListValue],
    -- | The lifetime for phase 2 of the IKE negotiation, in seconds.
    TunnelOption -> Maybe Int
phase2LifetimeSeconds :: Prelude.Maybe Prelude.Int,
    -- | The pre-shared key (PSK) to establish initial authentication between the
    -- virtual private gateway and the customer gateway.
    TunnelOption -> Maybe Text
preSharedKey :: Prelude.Maybe Prelude.Text,
    -- | The percentage of the rekey window determined by
    -- @RekeyMarginTimeSeconds@ during which the rekey time is randomly
    -- selected.
    TunnelOption -> Maybe Int
rekeyFuzzPercentage :: Prelude.Maybe Prelude.Int,
    -- | The margin time, in seconds, before the phase 2 lifetime expires, during
    -- which the Amazon Web Services side of the VPN connection performs an IKE
    -- rekey.
    TunnelOption -> Maybe Int
rekeyMarginTimeSeconds :: Prelude.Maybe Prelude.Int,
    -- | The number of packets in an IKE replay window.
    TunnelOption -> Maybe Int
replayWindowSize :: Prelude.Maybe Prelude.Int,
    -- | The action to take when the establishing the VPN tunnels for a VPN
    -- connection.
    TunnelOption -> Maybe Text
startupAction :: Prelude.Maybe Prelude.Text,
    -- | The range of inside IPv4 addresses for the tunnel.
    TunnelOption -> Maybe Text
tunnelInsideCidr :: Prelude.Maybe Prelude.Text,
    -- | The range of inside IPv6 addresses for the tunnel.
    TunnelOption -> Maybe Text
tunnelInsideIpv6Cidr :: Prelude.Maybe Prelude.Text
  }
  deriving (TunnelOption -> TunnelOption -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TunnelOption -> TunnelOption -> Bool
$c/= :: TunnelOption -> TunnelOption -> Bool
== :: TunnelOption -> TunnelOption -> Bool
$c== :: TunnelOption -> TunnelOption -> Bool
Prelude.Eq, ReadPrec [TunnelOption]
ReadPrec TunnelOption
Int -> ReadS TunnelOption
ReadS [TunnelOption]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TunnelOption]
$creadListPrec :: ReadPrec [TunnelOption]
readPrec :: ReadPrec TunnelOption
$creadPrec :: ReadPrec TunnelOption
readList :: ReadS [TunnelOption]
$creadList :: ReadS [TunnelOption]
readsPrec :: Int -> ReadS TunnelOption
$creadsPrec :: Int -> ReadS TunnelOption
Prelude.Read, Int -> TunnelOption -> ShowS
[TunnelOption] -> ShowS
TunnelOption -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TunnelOption] -> ShowS
$cshowList :: [TunnelOption] -> ShowS
show :: TunnelOption -> String
$cshow :: TunnelOption -> String
showsPrec :: Int -> TunnelOption -> ShowS
$cshowsPrec :: Int -> TunnelOption -> ShowS
Prelude.Show, forall x. Rep TunnelOption x -> TunnelOption
forall x. TunnelOption -> Rep TunnelOption x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TunnelOption x -> TunnelOption
$cfrom :: forall x. TunnelOption -> Rep TunnelOption x
Prelude.Generic)

-- |
-- Create a value of 'TunnelOption' 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:
--
-- 'dpdTimeoutAction', 'tunnelOption_dpdTimeoutAction' - The action to take after a DPD timeout occurs.
--
-- 'dpdTimeoutSeconds', 'tunnelOption_dpdTimeoutSeconds' - The number of seconds after which a DPD timeout occurs.
--
-- 'ikeVersions', 'tunnelOption_ikeVersions' - The IKE versions that are permitted for the VPN tunnel.
--
-- 'logOptions', 'tunnelOption_logOptions' - Options for logging VPN tunnel activity.
--
-- 'outsideIpAddress', 'tunnelOption_outsideIpAddress' - The external IP address of the VPN tunnel.
--
-- 'phase1DHGroupNumbers', 'tunnelOption_phase1DHGroupNumbers' - The permitted Diffie-Hellman group numbers for the VPN tunnel for phase
-- 1 IKE negotiations.
--
-- 'phase1EncryptionAlgorithms', 'tunnelOption_phase1EncryptionAlgorithms' - The permitted encryption algorithms for the VPN tunnel for phase 1 IKE
-- negotiations.
--
-- 'phase1IntegrityAlgorithms', 'tunnelOption_phase1IntegrityAlgorithms' - The permitted integrity algorithms for the VPN tunnel for phase 1 IKE
-- negotiations.
--
-- 'phase1LifetimeSeconds', 'tunnelOption_phase1LifetimeSeconds' - The lifetime for phase 1 of the IKE negotiation, in seconds.
--
-- 'phase2DHGroupNumbers', 'tunnelOption_phase2DHGroupNumbers' - The permitted Diffie-Hellman group numbers for the VPN tunnel for phase
-- 2 IKE negotiations.
--
-- 'phase2EncryptionAlgorithms', 'tunnelOption_phase2EncryptionAlgorithms' - The permitted encryption algorithms for the VPN tunnel for phase 2 IKE
-- negotiations.
--
-- 'phase2IntegrityAlgorithms', 'tunnelOption_phase2IntegrityAlgorithms' - The permitted integrity algorithms for the VPN tunnel for phase 2 IKE
-- negotiations.
--
-- 'phase2LifetimeSeconds', 'tunnelOption_phase2LifetimeSeconds' - The lifetime for phase 2 of the IKE negotiation, in seconds.
--
-- 'preSharedKey', 'tunnelOption_preSharedKey' - The pre-shared key (PSK) to establish initial authentication between the
-- virtual private gateway and the customer gateway.
--
-- 'rekeyFuzzPercentage', 'tunnelOption_rekeyFuzzPercentage' - The percentage of the rekey window determined by
-- @RekeyMarginTimeSeconds@ during which the rekey time is randomly
-- selected.
--
-- 'rekeyMarginTimeSeconds', 'tunnelOption_rekeyMarginTimeSeconds' - The margin time, in seconds, before the phase 2 lifetime expires, during
-- which the Amazon Web Services side of the VPN connection performs an IKE
-- rekey.
--
-- 'replayWindowSize', 'tunnelOption_replayWindowSize' - The number of packets in an IKE replay window.
--
-- 'startupAction', 'tunnelOption_startupAction' - The action to take when the establishing the VPN tunnels for a VPN
-- connection.
--
-- 'tunnelInsideCidr', 'tunnelOption_tunnelInsideCidr' - The range of inside IPv4 addresses for the tunnel.
--
-- 'tunnelInsideIpv6Cidr', 'tunnelOption_tunnelInsideIpv6Cidr' - The range of inside IPv6 addresses for the tunnel.
newTunnelOption ::
  TunnelOption
newTunnelOption :: TunnelOption
newTunnelOption =
  TunnelOption'
    { $sel:dpdTimeoutAction:TunnelOption' :: Maybe Text
dpdTimeoutAction = forall a. Maybe a
Prelude.Nothing,
      $sel:dpdTimeoutSeconds:TunnelOption' :: Maybe Int
dpdTimeoutSeconds = forall a. Maybe a
Prelude.Nothing,
      $sel:ikeVersions:TunnelOption' :: Maybe [IKEVersionsListValue]
ikeVersions = forall a. Maybe a
Prelude.Nothing,
      $sel:logOptions:TunnelOption' :: Maybe VpnTunnelLogOptions
logOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:outsideIpAddress:TunnelOption' :: Maybe Text
outsideIpAddress = forall a. Maybe a
Prelude.Nothing,
      $sel:phase1DHGroupNumbers:TunnelOption' :: Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers = forall a. Maybe a
Prelude.Nothing,
      $sel:phase1EncryptionAlgorithms:TunnelOption' :: Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms = forall a. Maybe a
Prelude.Nothing,
      $sel:phase1IntegrityAlgorithms:TunnelOption' :: Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms = forall a. Maybe a
Prelude.Nothing,
      $sel:phase1LifetimeSeconds:TunnelOption' :: Maybe Int
phase1LifetimeSeconds = forall a. Maybe a
Prelude.Nothing,
      $sel:phase2DHGroupNumbers:TunnelOption' :: Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers = forall a. Maybe a
Prelude.Nothing,
      $sel:phase2EncryptionAlgorithms:TunnelOption' :: Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms = forall a. Maybe a
Prelude.Nothing,
      $sel:phase2IntegrityAlgorithms:TunnelOption' :: Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms = forall a. Maybe a
Prelude.Nothing,
      $sel:phase2LifetimeSeconds:TunnelOption' :: Maybe Int
phase2LifetimeSeconds = forall a. Maybe a
Prelude.Nothing,
      $sel:preSharedKey:TunnelOption' :: Maybe Text
preSharedKey = forall a. Maybe a
Prelude.Nothing,
      $sel:rekeyFuzzPercentage:TunnelOption' :: Maybe Int
rekeyFuzzPercentage = forall a. Maybe a
Prelude.Nothing,
      $sel:rekeyMarginTimeSeconds:TunnelOption' :: Maybe Int
rekeyMarginTimeSeconds = forall a. Maybe a
Prelude.Nothing,
      $sel:replayWindowSize:TunnelOption' :: Maybe Int
replayWindowSize = forall a. Maybe a
Prelude.Nothing,
      $sel:startupAction:TunnelOption' :: Maybe Text
startupAction = forall a. Maybe a
Prelude.Nothing,
      $sel:tunnelInsideCidr:TunnelOption' :: Maybe Text
tunnelInsideCidr = forall a. Maybe a
Prelude.Nothing,
      $sel:tunnelInsideIpv6Cidr:TunnelOption' :: Maybe Text
tunnelInsideIpv6Cidr = forall a. Maybe a
Prelude.Nothing
    }

-- | The action to take after a DPD timeout occurs.
tunnelOption_dpdTimeoutAction :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Text)
tunnelOption_dpdTimeoutAction :: Lens' TunnelOption (Maybe Text)
tunnelOption_dpdTimeoutAction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Text
dpdTimeoutAction :: Maybe Text
$sel:dpdTimeoutAction:TunnelOption' :: TunnelOption -> Maybe Text
dpdTimeoutAction} -> Maybe Text
dpdTimeoutAction) (\s :: TunnelOption
s@TunnelOption' {} Maybe Text
a -> TunnelOption
s {$sel:dpdTimeoutAction:TunnelOption' :: Maybe Text
dpdTimeoutAction = Maybe Text
a} :: TunnelOption)

-- | The number of seconds after which a DPD timeout occurs.
tunnelOption_dpdTimeoutSeconds :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Int)
tunnelOption_dpdTimeoutSeconds :: Lens' TunnelOption (Maybe Int)
tunnelOption_dpdTimeoutSeconds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Int
dpdTimeoutSeconds :: Maybe Int
$sel:dpdTimeoutSeconds:TunnelOption' :: TunnelOption -> Maybe Int
dpdTimeoutSeconds} -> Maybe Int
dpdTimeoutSeconds) (\s :: TunnelOption
s@TunnelOption' {} Maybe Int
a -> TunnelOption
s {$sel:dpdTimeoutSeconds:TunnelOption' :: Maybe Int
dpdTimeoutSeconds = Maybe Int
a} :: TunnelOption)

-- | The IKE versions that are permitted for the VPN tunnel.
tunnelOption_ikeVersions :: Lens.Lens' TunnelOption (Prelude.Maybe [IKEVersionsListValue])
tunnelOption_ikeVersions :: Lens' TunnelOption (Maybe [IKEVersionsListValue])
tunnelOption_ikeVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe [IKEVersionsListValue]
ikeVersions :: Maybe [IKEVersionsListValue]
$sel:ikeVersions:TunnelOption' :: TunnelOption -> Maybe [IKEVersionsListValue]
ikeVersions} -> Maybe [IKEVersionsListValue]
ikeVersions) (\s :: TunnelOption
s@TunnelOption' {} Maybe [IKEVersionsListValue]
a -> TunnelOption
s {$sel:ikeVersions:TunnelOption' :: Maybe [IKEVersionsListValue]
ikeVersions = Maybe [IKEVersionsListValue]
a} :: TunnelOption) 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

-- | Options for logging VPN tunnel activity.
tunnelOption_logOptions :: Lens.Lens' TunnelOption (Prelude.Maybe VpnTunnelLogOptions)
tunnelOption_logOptions :: Lens' TunnelOption (Maybe VpnTunnelLogOptions)
tunnelOption_logOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe VpnTunnelLogOptions
logOptions :: Maybe VpnTunnelLogOptions
$sel:logOptions:TunnelOption' :: TunnelOption -> Maybe VpnTunnelLogOptions
logOptions} -> Maybe VpnTunnelLogOptions
logOptions) (\s :: TunnelOption
s@TunnelOption' {} Maybe VpnTunnelLogOptions
a -> TunnelOption
s {$sel:logOptions:TunnelOption' :: Maybe VpnTunnelLogOptions
logOptions = Maybe VpnTunnelLogOptions
a} :: TunnelOption)

-- | The external IP address of the VPN tunnel.
tunnelOption_outsideIpAddress :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Text)
tunnelOption_outsideIpAddress :: Lens' TunnelOption (Maybe Text)
tunnelOption_outsideIpAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Text
outsideIpAddress :: Maybe Text
$sel:outsideIpAddress:TunnelOption' :: TunnelOption -> Maybe Text
outsideIpAddress} -> Maybe Text
outsideIpAddress) (\s :: TunnelOption
s@TunnelOption' {} Maybe Text
a -> TunnelOption
s {$sel:outsideIpAddress:TunnelOption' :: Maybe Text
outsideIpAddress = Maybe Text
a} :: TunnelOption)

-- | The permitted Diffie-Hellman group numbers for the VPN tunnel for phase
-- 1 IKE negotiations.
tunnelOption_phase1DHGroupNumbers :: Lens.Lens' TunnelOption (Prelude.Maybe [Phase1DHGroupNumbersListValue])
tunnelOption_phase1DHGroupNumbers :: Lens' TunnelOption (Maybe [Phase1DHGroupNumbersListValue])
tunnelOption_phase1DHGroupNumbers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers :: Maybe [Phase1DHGroupNumbersListValue]
$sel:phase1DHGroupNumbers:TunnelOption' :: TunnelOption -> Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers} -> Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers) (\s :: TunnelOption
s@TunnelOption' {} Maybe [Phase1DHGroupNumbersListValue]
a -> TunnelOption
s {$sel:phase1DHGroupNumbers:TunnelOption' :: Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers = Maybe [Phase1DHGroupNumbersListValue]
a} :: TunnelOption) 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

-- | The permitted encryption algorithms for the VPN tunnel for phase 1 IKE
-- negotiations.
tunnelOption_phase1EncryptionAlgorithms :: Lens.Lens' TunnelOption (Prelude.Maybe [Phase1EncryptionAlgorithmsListValue])
tunnelOption_phase1EncryptionAlgorithms :: Lens' TunnelOption (Maybe [Phase1EncryptionAlgorithmsListValue])
tunnelOption_phase1EncryptionAlgorithms = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms :: Maybe [Phase1EncryptionAlgorithmsListValue]
$sel:phase1EncryptionAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms} -> Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms) (\s :: TunnelOption
s@TunnelOption' {} Maybe [Phase1EncryptionAlgorithmsListValue]
a -> TunnelOption
s {$sel:phase1EncryptionAlgorithms:TunnelOption' :: Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms = Maybe [Phase1EncryptionAlgorithmsListValue]
a} :: TunnelOption) 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

-- | The permitted integrity algorithms for the VPN tunnel for phase 1 IKE
-- negotiations.
tunnelOption_phase1IntegrityAlgorithms :: Lens.Lens' TunnelOption (Prelude.Maybe [Phase1IntegrityAlgorithmsListValue])
tunnelOption_phase1IntegrityAlgorithms :: Lens' TunnelOption (Maybe [Phase1IntegrityAlgorithmsListValue])
tunnelOption_phase1IntegrityAlgorithms = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms :: Maybe [Phase1IntegrityAlgorithmsListValue]
$sel:phase1IntegrityAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms} -> Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms) (\s :: TunnelOption
s@TunnelOption' {} Maybe [Phase1IntegrityAlgorithmsListValue]
a -> TunnelOption
s {$sel:phase1IntegrityAlgorithms:TunnelOption' :: Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms = Maybe [Phase1IntegrityAlgorithmsListValue]
a} :: TunnelOption) 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

-- | The lifetime for phase 1 of the IKE negotiation, in seconds.
tunnelOption_phase1LifetimeSeconds :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Int)
tunnelOption_phase1LifetimeSeconds :: Lens' TunnelOption (Maybe Int)
tunnelOption_phase1LifetimeSeconds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Int
phase1LifetimeSeconds :: Maybe Int
$sel:phase1LifetimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
phase1LifetimeSeconds} -> Maybe Int
phase1LifetimeSeconds) (\s :: TunnelOption
s@TunnelOption' {} Maybe Int
a -> TunnelOption
s {$sel:phase1LifetimeSeconds:TunnelOption' :: Maybe Int
phase1LifetimeSeconds = Maybe Int
a} :: TunnelOption)

-- | The permitted Diffie-Hellman group numbers for the VPN tunnel for phase
-- 2 IKE negotiations.
tunnelOption_phase2DHGroupNumbers :: Lens.Lens' TunnelOption (Prelude.Maybe [Phase2DHGroupNumbersListValue])
tunnelOption_phase2DHGroupNumbers :: Lens' TunnelOption (Maybe [Phase2DHGroupNumbersListValue])
tunnelOption_phase2DHGroupNumbers = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers :: Maybe [Phase2DHGroupNumbersListValue]
$sel:phase2DHGroupNumbers:TunnelOption' :: TunnelOption -> Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers} -> Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers) (\s :: TunnelOption
s@TunnelOption' {} Maybe [Phase2DHGroupNumbersListValue]
a -> TunnelOption
s {$sel:phase2DHGroupNumbers:TunnelOption' :: Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers = Maybe [Phase2DHGroupNumbersListValue]
a} :: TunnelOption) 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

-- | The permitted encryption algorithms for the VPN tunnel for phase 2 IKE
-- negotiations.
tunnelOption_phase2EncryptionAlgorithms :: Lens.Lens' TunnelOption (Prelude.Maybe [Phase2EncryptionAlgorithmsListValue])
tunnelOption_phase2EncryptionAlgorithms :: Lens' TunnelOption (Maybe [Phase2EncryptionAlgorithmsListValue])
tunnelOption_phase2EncryptionAlgorithms = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms :: Maybe [Phase2EncryptionAlgorithmsListValue]
$sel:phase2EncryptionAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms} -> Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms) (\s :: TunnelOption
s@TunnelOption' {} Maybe [Phase2EncryptionAlgorithmsListValue]
a -> TunnelOption
s {$sel:phase2EncryptionAlgorithms:TunnelOption' :: Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms = Maybe [Phase2EncryptionAlgorithmsListValue]
a} :: TunnelOption) 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

-- | The permitted integrity algorithms for the VPN tunnel for phase 2 IKE
-- negotiations.
tunnelOption_phase2IntegrityAlgorithms :: Lens.Lens' TunnelOption (Prelude.Maybe [Phase2IntegrityAlgorithmsListValue])
tunnelOption_phase2IntegrityAlgorithms :: Lens' TunnelOption (Maybe [Phase2IntegrityAlgorithmsListValue])
tunnelOption_phase2IntegrityAlgorithms = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms :: Maybe [Phase2IntegrityAlgorithmsListValue]
$sel:phase2IntegrityAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms} -> Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms) (\s :: TunnelOption
s@TunnelOption' {} Maybe [Phase2IntegrityAlgorithmsListValue]
a -> TunnelOption
s {$sel:phase2IntegrityAlgorithms:TunnelOption' :: Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms = Maybe [Phase2IntegrityAlgorithmsListValue]
a} :: TunnelOption) 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

-- | The lifetime for phase 2 of the IKE negotiation, in seconds.
tunnelOption_phase2LifetimeSeconds :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Int)
tunnelOption_phase2LifetimeSeconds :: Lens' TunnelOption (Maybe Int)
tunnelOption_phase2LifetimeSeconds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Int
phase2LifetimeSeconds :: Maybe Int
$sel:phase2LifetimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
phase2LifetimeSeconds} -> Maybe Int
phase2LifetimeSeconds) (\s :: TunnelOption
s@TunnelOption' {} Maybe Int
a -> TunnelOption
s {$sel:phase2LifetimeSeconds:TunnelOption' :: Maybe Int
phase2LifetimeSeconds = Maybe Int
a} :: TunnelOption)

-- | The pre-shared key (PSK) to establish initial authentication between the
-- virtual private gateway and the customer gateway.
tunnelOption_preSharedKey :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Text)
tunnelOption_preSharedKey :: Lens' TunnelOption (Maybe Text)
tunnelOption_preSharedKey = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Text
preSharedKey :: Maybe Text
$sel:preSharedKey:TunnelOption' :: TunnelOption -> Maybe Text
preSharedKey} -> Maybe Text
preSharedKey) (\s :: TunnelOption
s@TunnelOption' {} Maybe Text
a -> TunnelOption
s {$sel:preSharedKey:TunnelOption' :: Maybe Text
preSharedKey = Maybe Text
a} :: TunnelOption)

-- | The percentage of the rekey window determined by
-- @RekeyMarginTimeSeconds@ during which the rekey time is randomly
-- selected.
tunnelOption_rekeyFuzzPercentage :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Int)
tunnelOption_rekeyFuzzPercentage :: Lens' TunnelOption (Maybe Int)
tunnelOption_rekeyFuzzPercentage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Int
rekeyFuzzPercentage :: Maybe Int
$sel:rekeyFuzzPercentage:TunnelOption' :: TunnelOption -> Maybe Int
rekeyFuzzPercentage} -> Maybe Int
rekeyFuzzPercentage) (\s :: TunnelOption
s@TunnelOption' {} Maybe Int
a -> TunnelOption
s {$sel:rekeyFuzzPercentage:TunnelOption' :: Maybe Int
rekeyFuzzPercentage = Maybe Int
a} :: TunnelOption)

-- | The margin time, in seconds, before the phase 2 lifetime expires, during
-- which the Amazon Web Services side of the VPN connection performs an IKE
-- rekey.
tunnelOption_rekeyMarginTimeSeconds :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Int)
tunnelOption_rekeyMarginTimeSeconds :: Lens' TunnelOption (Maybe Int)
tunnelOption_rekeyMarginTimeSeconds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Int
rekeyMarginTimeSeconds :: Maybe Int
$sel:rekeyMarginTimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
rekeyMarginTimeSeconds} -> Maybe Int
rekeyMarginTimeSeconds) (\s :: TunnelOption
s@TunnelOption' {} Maybe Int
a -> TunnelOption
s {$sel:rekeyMarginTimeSeconds:TunnelOption' :: Maybe Int
rekeyMarginTimeSeconds = Maybe Int
a} :: TunnelOption)

-- | The number of packets in an IKE replay window.
tunnelOption_replayWindowSize :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Int)
tunnelOption_replayWindowSize :: Lens' TunnelOption (Maybe Int)
tunnelOption_replayWindowSize = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Int
replayWindowSize :: Maybe Int
$sel:replayWindowSize:TunnelOption' :: TunnelOption -> Maybe Int
replayWindowSize} -> Maybe Int
replayWindowSize) (\s :: TunnelOption
s@TunnelOption' {} Maybe Int
a -> TunnelOption
s {$sel:replayWindowSize:TunnelOption' :: Maybe Int
replayWindowSize = Maybe Int
a} :: TunnelOption)

-- | The action to take when the establishing the VPN tunnels for a VPN
-- connection.
tunnelOption_startupAction :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Text)
tunnelOption_startupAction :: Lens' TunnelOption (Maybe Text)
tunnelOption_startupAction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Text
startupAction :: Maybe Text
$sel:startupAction:TunnelOption' :: TunnelOption -> Maybe Text
startupAction} -> Maybe Text
startupAction) (\s :: TunnelOption
s@TunnelOption' {} Maybe Text
a -> TunnelOption
s {$sel:startupAction:TunnelOption' :: Maybe Text
startupAction = Maybe Text
a} :: TunnelOption)

-- | The range of inside IPv4 addresses for the tunnel.
tunnelOption_tunnelInsideCidr :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Text)
tunnelOption_tunnelInsideCidr :: Lens' TunnelOption (Maybe Text)
tunnelOption_tunnelInsideCidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Text
tunnelInsideCidr :: Maybe Text
$sel:tunnelInsideCidr:TunnelOption' :: TunnelOption -> Maybe Text
tunnelInsideCidr} -> Maybe Text
tunnelInsideCidr) (\s :: TunnelOption
s@TunnelOption' {} Maybe Text
a -> TunnelOption
s {$sel:tunnelInsideCidr:TunnelOption' :: Maybe Text
tunnelInsideCidr = Maybe Text
a} :: TunnelOption)

-- | The range of inside IPv6 addresses for the tunnel.
tunnelOption_tunnelInsideIpv6Cidr :: Lens.Lens' TunnelOption (Prelude.Maybe Prelude.Text)
tunnelOption_tunnelInsideIpv6Cidr :: Lens' TunnelOption (Maybe Text)
tunnelOption_tunnelInsideIpv6Cidr = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\TunnelOption' {Maybe Text
tunnelInsideIpv6Cidr :: Maybe Text
$sel:tunnelInsideIpv6Cidr:TunnelOption' :: TunnelOption -> Maybe Text
tunnelInsideIpv6Cidr} -> Maybe Text
tunnelInsideIpv6Cidr) (\s :: TunnelOption
s@TunnelOption' {} Maybe Text
a -> TunnelOption
s {$sel:tunnelInsideIpv6Cidr:TunnelOption' :: Maybe Text
tunnelInsideIpv6Cidr = Maybe Text
a} :: TunnelOption)

instance Data.FromXML TunnelOption where
  parseXML :: [Node] -> Either String TunnelOption
parseXML [Node]
x =
    Maybe Text
-> Maybe Int
-> Maybe [IKEVersionsListValue]
-> Maybe VpnTunnelLogOptions
-> Maybe Text
-> Maybe [Phase1DHGroupNumbersListValue]
-> Maybe [Phase1EncryptionAlgorithmsListValue]
-> Maybe [Phase1IntegrityAlgorithmsListValue]
-> Maybe Int
-> Maybe [Phase2DHGroupNumbersListValue]
-> Maybe [Phase2EncryptionAlgorithmsListValue]
-> Maybe [Phase2IntegrityAlgorithmsListValue]
-> Maybe Int
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> TunnelOption
TunnelOption'
      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
"dpdTimeoutAction")
      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
"dpdTimeoutSeconds")
      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
"ikeVersionSet"
                      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")
                  )
      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
"logOptions")
      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
"outsideIpAddress")
      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
"phase1DHGroupNumberSet"
                      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")
                  )
      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
"phase1EncryptionAlgorithmSet"
                      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")
                  )
      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
"phase1IntegrityAlgorithmSet"
                      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")
                  )
      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
"phase1LifetimeSeconds")
      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
"phase2DHGroupNumberSet"
                      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")
                  )
      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
"phase2EncryptionAlgorithmSet"
                      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")
                  )
      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
"phase2IntegrityAlgorithmSet"
                      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")
                  )
      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
"phase2LifetimeSeconds")
      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
"preSharedKey")
      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
"rekeyFuzzPercentage")
      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
"rekeyMarginTimeSeconds")
      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
"replayWindowSize")
      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
"startupAction")
      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
"tunnelInsideCidr")
      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
"tunnelInsideIpv6Cidr")

instance Prelude.Hashable TunnelOption where
  hashWithSalt :: Int -> TunnelOption -> Int
hashWithSalt Int
_salt TunnelOption' {Maybe Int
Maybe [IKEVersionsListValue]
Maybe [Phase1DHGroupNumbersListValue]
Maybe [Phase1EncryptionAlgorithmsListValue]
Maybe [Phase1IntegrityAlgorithmsListValue]
Maybe [Phase2DHGroupNumbersListValue]
Maybe [Phase2EncryptionAlgorithmsListValue]
Maybe [Phase2IntegrityAlgorithmsListValue]
Maybe Text
Maybe VpnTunnelLogOptions
tunnelInsideIpv6Cidr :: Maybe Text
tunnelInsideCidr :: Maybe Text
startupAction :: Maybe Text
replayWindowSize :: Maybe Int
rekeyMarginTimeSeconds :: Maybe Int
rekeyFuzzPercentage :: Maybe Int
preSharedKey :: Maybe Text
phase2LifetimeSeconds :: Maybe Int
phase2IntegrityAlgorithms :: Maybe [Phase2IntegrityAlgorithmsListValue]
phase2EncryptionAlgorithms :: Maybe [Phase2EncryptionAlgorithmsListValue]
phase2DHGroupNumbers :: Maybe [Phase2DHGroupNumbersListValue]
phase1LifetimeSeconds :: Maybe Int
phase1IntegrityAlgorithms :: Maybe [Phase1IntegrityAlgorithmsListValue]
phase1EncryptionAlgorithms :: Maybe [Phase1EncryptionAlgorithmsListValue]
phase1DHGroupNumbers :: Maybe [Phase1DHGroupNumbersListValue]
outsideIpAddress :: Maybe Text
logOptions :: Maybe VpnTunnelLogOptions
ikeVersions :: Maybe [IKEVersionsListValue]
dpdTimeoutSeconds :: Maybe Int
dpdTimeoutAction :: Maybe Text
$sel:tunnelInsideIpv6Cidr:TunnelOption' :: TunnelOption -> Maybe Text
$sel:tunnelInsideCidr:TunnelOption' :: TunnelOption -> Maybe Text
$sel:startupAction:TunnelOption' :: TunnelOption -> Maybe Text
$sel:replayWindowSize:TunnelOption' :: TunnelOption -> Maybe Int
$sel:rekeyMarginTimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:rekeyFuzzPercentage:TunnelOption' :: TunnelOption -> Maybe Int
$sel:preSharedKey:TunnelOption' :: TunnelOption -> Maybe Text
$sel:phase2LifetimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:phase2IntegrityAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase2IntegrityAlgorithmsListValue]
$sel:phase2EncryptionAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase2EncryptionAlgorithmsListValue]
$sel:phase2DHGroupNumbers:TunnelOption' :: TunnelOption -> Maybe [Phase2DHGroupNumbersListValue]
$sel:phase1LifetimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:phase1IntegrityAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase1IntegrityAlgorithmsListValue]
$sel:phase1EncryptionAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase1EncryptionAlgorithmsListValue]
$sel:phase1DHGroupNumbers:TunnelOption' :: TunnelOption -> Maybe [Phase1DHGroupNumbersListValue]
$sel:outsideIpAddress:TunnelOption' :: TunnelOption -> Maybe Text
$sel:logOptions:TunnelOption' :: TunnelOption -> Maybe VpnTunnelLogOptions
$sel:ikeVersions:TunnelOption' :: TunnelOption -> Maybe [IKEVersionsListValue]
$sel:dpdTimeoutSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:dpdTimeoutAction:TunnelOption' :: TunnelOption -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dpdTimeoutAction
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
dpdTimeoutSeconds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [IKEVersionsListValue]
ikeVersions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VpnTunnelLogOptions
logOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
outsideIpAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
phase1LifetimeSeconds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
phase2LifetimeSeconds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
preSharedKey
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
rekeyFuzzPercentage
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
rekeyMarginTimeSeconds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
replayWindowSize
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
startupAction
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
tunnelInsideCidr
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
tunnelInsideIpv6Cidr

instance Prelude.NFData TunnelOption where
  rnf :: TunnelOption -> ()
rnf TunnelOption' {Maybe Int
Maybe [IKEVersionsListValue]
Maybe [Phase1DHGroupNumbersListValue]
Maybe [Phase1EncryptionAlgorithmsListValue]
Maybe [Phase1IntegrityAlgorithmsListValue]
Maybe [Phase2DHGroupNumbersListValue]
Maybe [Phase2EncryptionAlgorithmsListValue]
Maybe [Phase2IntegrityAlgorithmsListValue]
Maybe Text
Maybe VpnTunnelLogOptions
tunnelInsideIpv6Cidr :: Maybe Text
tunnelInsideCidr :: Maybe Text
startupAction :: Maybe Text
replayWindowSize :: Maybe Int
rekeyMarginTimeSeconds :: Maybe Int
rekeyFuzzPercentage :: Maybe Int
preSharedKey :: Maybe Text
phase2LifetimeSeconds :: Maybe Int
phase2IntegrityAlgorithms :: Maybe [Phase2IntegrityAlgorithmsListValue]
phase2EncryptionAlgorithms :: Maybe [Phase2EncryptionAlgorithmsListValue]
phase2DHGroupNumbers :: Maybe [Phase2DHGroupNumbersListValue]
phase1LifetimeSeconds :: Maybe Int
phase1IntegrityAlgorithms :: Maybe [Phase1IntegrityAlgorithmsListValue]
phase1EncryptionAlgorithms :: Maybe [Phase1EncryptionAlgorithmsListValue]
phase1DHGroupNumbers :: Maybe [Phase1DHGroupNumbersListValue]
outsideIpAddress :: Maybe Text
logOptions :: Maybe VpnTunnelLogOptions
ikeVersions :: Maybe [IKEVersionsListValue]
dpdTimeoutSeconds :: Maybe Int
dpdTimeoutAction :: Maybe Text
$sel:tunnelInsideIpv6Cidr:TunnelOption' :: TunnelOption -> Maybe Text
$sel:tunnelInsideCidr:TunnelOption' :: TunnelOption -> Maybe Text
$sel:startupAction:TunnelOption' :: TunnelOption -> Maybe Text
$sel:replayWindowSize:TunnelOption' :: TunnelOption -> Maybe Int
$sel:rekeyMarginTimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:rekeyFuzzPercentage:TunnelOption' :: TunnelOption -> Maybe Int
$sel:preSharedKey:TunnelOption' :: TunnelOption -> Maybe Text
$sel:phase2LifetimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:phase2IntegrityAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase2IntegrityAlgorithmsListValue]
$sel:phase2EncryptionAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase2EncryptionAlgorithmsListValue]
$sel:phase2DHGroupNumbers:TunnelOption' :: TunnelOption -> Maybe [Phase2DHGroupNumbersListValue]
$sel:phase1LifetimeSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:phase1IntegrityAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase1IntegrityAlgorithmsListValue]
$sel:phase1EncryptionAlgorithms:TunnelOption' :: TunnelOption -> Maybe [Phase1EncryptionAlgorithmsListValue]
$sel:phase1DHGroupNumbers:TunnelOption' :: TunnelOption -> Maybe [Phase1DHGroupNumbersListValue]
$sel:outsideIpAddress:TunnelOption' :: TunnelOption -> Maybe Text
$sel:logOptions:TunnelOption' :: TunnelOption -> Maybe VpnTunnelLogOptions
$sel:ikeVersions:TunnelOption' :: TunnelOption -> Maybe [IKEVersionsListValue]
$sel:dpdTimeoutSeconds:TunnelOption' :: TunnelOption -> Maybe Int
$sel:dpdTimeoutAction:TunnelOption' :: TunnelOption -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dpdTimeoutAction
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
dpdTimeoutSeconds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [IKEVersionsListValue]
ikeVersions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VpnTunnelLogOptions
logOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
outsideIpAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Phase1DHGroupNumbersListValue]
phase1DHGroupNumbers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Phase1EncryptionAlgorithmsListValue]
phase1EncryptionAlgorithms
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Phase1IntegrityAlgorithmsListValue]
phase1IntegrityAlgorithms
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
phase1LifetimeSeconds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Phase2DHGroupNumbersListValue]
phase2DHGroupNumbers
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Phase2EncryptionAlgorithmsListValue]
phase2EncryptionAlgorithms
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Phase2IntegrityAlgorithmsListValue]
phase2IntegrityAlgorithms
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
phase2LifetimeSeconds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
preSharedKey
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
rekeyFuzzPercentage
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
rekeyMarginTimeSeconds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
replayWindowSize
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
startupAction
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
tunnelInsideCidr
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Text
tunnelInsideIpv6Cidr