{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# 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.ModifyVpnTunnelOptions
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Modifies the options for a VPN tunnel in an Amazon Web Services
-- Site-to-Site VPN connection. You can modify multiple options for a
-- tunnel in a single request, but you can only modify one tunnel at a
-- time. For more information, see
-- <https://docs.aws.amazon.com/vpn/latest/s2svpn/VPNTunnels.html Site-to-Site VPN tunnel options for your Site-to-Site VPN connection>
-- in the /Amazon Web Services Site-to-Site VPN User Guide/.
module Amazonka.EC2.ModifyVpnTunnelOptions
  ( -- * Creating a Request
    ModifyVpnTunnelOptions (..),
    newModifyVpnTunnelOptions,

    -- * Request Lenses
    modifyVpnTunnelOptions_dryRun,
    modifyVpnTunnelOptions_vpnConnectionId,
    modifyVpnTunnelOptions_vpnTunnelOutsideIpAddress,
    modifyVpnTunnelOptions_tunnelOptions,

    -- * Destructuring the Response
    ModifyVpnTunnelOptionsResponse (..),
    newModifyVpnTunnelOptionsResponse,

    -- * Response Lenses
    modifyVpnTunnelOptionsResponse_vpnConnection,
    modifyVpnTunnelOptionsResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newModifyVpnTunnelOptions' smart constructor.
data ModifyVpnTunnelOptions = ModifyVpnTunnelOptions'
  { -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    ModifyVpnTunnelOptions -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The ID of the Amazon Web Services Site-to-Site VPN connection.
    ModifyVpnTunnelOptions -> Text
vpnConnectionId :: Prelude.Text,
    -- | The external IP address of the VPN tunnel.
    ModifyVpnTunnelOptions -> Text
vpnTunnelOutsideIpAddress :: Prelude.Text,
    -- | The tunnel options to modify.
    ModifyVpnTunnelOptions -> ModifyVpnTunnelOptionsSpecification
tunnelOptions :: ModifyVpnTunnelOptionsSpecification
  }
  deriving (ModifyVpnTunnelOptions -> ModifyVpnTunnelOptions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptions -> Bool
$c/= :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptions -> Bool
== :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptions -> Bool
$c== :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptions -> Bool
Prelude.Eq, ReadPrec [ModifyVpnTunnelOptions]
ReadPrec ModifyVpnTunnelOptions
Int -> ReadS ModifyVpnTunnelOptions
ReadS [ModifyVpnTunnelOptions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ModifyVpnTunnelOptions]
$creadListPrec :: ReadPrec [ModifyVpnTunnelOptions]
readPrec :: ReadPrec ModifyVpnTunnelOptions
$creadPrec :: ReadPrec ModifyVpnTunnelOptions
readList :: ReadS [ModifyVpnTunnelOptions]
$creadList :: ReadS [ModifyVpnTunnelOptions]
readsPrec :: Int -> ReadS ModifyVpnTunnelOptions
$creadsPrec :: Int -> ReadS ModifyVpnTunnelOptions
Prelude.Read, Int -> ModifyVpnTunnelOptions -> ShowS
[ModifyVpnTunnelOptions] -> ShowS
ModifyVpnTunnelOptions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifyVpnTunnelOptions] -> ShowS
$cshowList :: [ModifyVpnTunnelOptions] -> ShowS
show :: ModifyVpnTunnelOptions -> String
$cshow :: ModifyVpnTunnelOptions -> String
showsPrec :: Int -> ModifyVpnTunnelOptions -> ShowS
$cshowsPrec :: Int -> ModifyVpnTunnelOptions -> ShowS
Prelude.Show, forall x. Rep ModifyVpnTunnelOptions x -> ModifyVpnTunnelOptions
forall x. ModifyVpnTunnelOptions -> Rep ModifyVpnTunnelOptions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModifyVpnTunnelOptions x -> ModifyVpnTunnelOptions
$cfrom :: forall x. ModifyVpnTunnelOptions -> Rep ModifyVpnTunnelOptions x
Prelude.Generic)

-- |
-- Create a value of 'ModifyVpnTunnelOptions' 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:
--
-- 'dryRun', 'modifyVpnTunnelOptions_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'vpnConnectionId', 'modifyVpnTunnelOptions_vpnConnectionId' - The ID of the Amazon Web Services Site-to-Site VPN connection.
--
-- 'vpnTunnelOutsideIpAddress', 'modifyVpnTunnelOptions_vpnTunnelOutsideIpAddress' - The external IP address of the VPN tunnel.
--
-- 'tunnelOptions', 'modifyVpnTunnelOptions_tunnelOptions' - The tunnel options to modify.
newModifyVpnTunnelOptions ::
  -- | 'vpnConnectionId'
  Prelude.Text ->
  -- | 'vpnTunnelOutsideIpAddress'
  Prelude.Text ->
  -- | 'tunnelOptions'
  ModifyVpnTunnelOptionsSpecification ->
  ModifyVpnTunnelOptions
newModifyVpnTunnelOptions :: Text
-> Text
-> ModifyVpnTunnelOptionsSpecification
-> ModifyVpnTunnelOptions
newModifyVpnTunnelOptions
  Text
pVpnConnectionId_
  Text
pVpnTunnelOutsideIpAddress_
  ModifyVpnTunnelOptionsSpecification
pTunnelOptions_ =
    ModifyVpnTunnelOptions'
      { $sel:dryRun:ModifyVpnTunnelOptions' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
        $sel:vpnConnectionId:ModifyVpnTunnelOptions' :: Text
vpnConnectionId = Text
pVpnConnectionId_,
        $sel:vpnTunnelOutsideIpAddress:ModifyVpnTunnelOptions' :: Text
vpnTunnelOutsideIpAddress =
          Text
pVpnTunnelOutsideIpAddress_,
        $sel:tunnelOptions:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptionsSpecification
tunnelOptions = ModifyVpnTunnelOptionsSpecification
pTunnelOptions_
      }

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
modifyVpnTunnelOptions_dryRun :: Lens.Lens' ModifyVpnTunnelOptions (Prelude.Maybe Prelude.Bool)
modifyVpnTunnelOptions_dryRun :: Lens' ModifyVpnTunnelOptions (Maybe Bool)
modifyVpnTunnelOptions_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyVpnTunnelOptions' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: ModifyVpnTunnelOptions
s@ModifyVpnTunnelOptions' {} Maybe Bool
a -> ModifyVpnTunnelOptions
s {$sel:dryRun:ModifyVpnTunnelOptions' :: Maybe Bool
dryRun = Maybe Bool
a} :: ModifyVpnTunnelOptions)

-- | The ID of the Amazon Web Services Site-to-Site VPN connection.
modifyVpnTunnelOptions_vpnConnectionId :: Lens.Lens' ModifyVpnTunnelOptions Prelude.Text
modifyVpnTunnelOptions_vpnConnectionId :: Lens' ModifyVpnTunnelOptions Text
modifyVpnTunnelOptions_vpnConnectionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyVpnTunnelOptions' {Text
vpnConnectionId :: Text
$sel:vpnConnectionId:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Text
vpnConnectionId} -> Text
vpnConnectionId) (\s :: ModifyVpnTunnelOptions
s@ModifyVpnTunnelOptions' {} Text
a -> ModifyVpnTunnelOptions
s {$sel:vpnConnectionId:ModifyVpnTunnelOptions' :: Text
vpnConnectionId = Text
a} :: ModifyVpnTunnelOptions)

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

-- | The tunnel options to modify.
modifyVpnTunnelOptions_tunnelOptions :: Lens.Lens' ModifyVpnTunnelOptions ModifyVpnTunnelOptionsSpecification
modifyVpnTunnelOptions_tunnelOptions :: Lens' ModifyVpnTunnelOptions ModifyVpnTunnelOptionsSpecification
modifyVpnTunnelOptions_tunnelOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyVpnTunnelOptions' {ModifyVpnTunnelOptionsSpecification
tunnelOptions :: ModifyVpnTunnelOptionsSpecification
$sel:tunnelOptions:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptionsSpecification
tunnelOptions} -> ModifyVpnTunnelOptionsSpecification
tunnelOptions) (\s :: ModifyVpnTunnelOptions
s@ModifyVpnTunnelOptions' {} ModifyVpnTunnelOptionsSpecification
a -> ModifyVpnTunnelOptions
s {$sel:tunnelOptions:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptionsSpecification
tunnelOptions = ModifyVpnTunnelOptionsSpecification
a} :: ModifyVpnTunnelOptions)

instance Core.AWSRequest ModifyVpnTunnelOptions where
  type
    AWSResponse ModifyVpnTunnelOptions =
      ModifyVpnTunnelOptionsResponse
  request :: (Service -> Service)
-> ModifyVpnTunnelOptions -> Request ModifyVpnTunnelOptions
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ModifyVpnTunnelOptions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ModifyVpnTunnelOptions)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe VpnConnection -> Int -> ModifyVpnTunnelOptionsResponse
ModifyVpnTunnelOptionsResponse'
            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
"vpnConnection")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ModifyVpnTunnelOptions where
  hashWithSalt :: Int -> ModifyVpnTunnelOptions -> Int
hashWithSalt Int
_salt ModifyVpnTunnelOptions' {Maybe Bool
Text
ModifyVpnTunnelOptionsSpecification
tunnelOptions :: ModifyVpnTunnelOptionsSpecification
vpnTunnelOutsideIpAddress :: Text
vpnConnectionId :: Text
dryRun :: Maybe Bool
$sel:tunnelOptions:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptionsSpecification
$sel:vpnTunnelOutsideIpAddress:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Text
$sel:vpnConnectionId:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Text
$sel:dryRun:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
vpnConnectionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
vpnTunnelOutsideIpAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ModifyVpnTunnelOptionsSpecification
tunnelOptions

instance Prelude.NFData ModifyVpnTunnelOptions where
  rnf :: ModifyVpnTunnelOptions -> ()
rnf ModifyVpnTunnelOptions' {Maybe Bool
Text
ModifyVpnTunnelOptionsSpecification
tunnelOptions :: ModifyVpnTunnelOptionsSpecification
vpnTunnelOutsideIpAddress :: Text
vpnConnectionId :: Text
dryRun :: Maybe Bool
$sel:tunnelOptions:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptionsSpecification
$sel:vpnTunnelOutsideIpAddress:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Text
$sel:vpnConnectionId:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Text
$sel:dryRun:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
vpnConnectionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
vpnTunnelOutsideIpAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ModifyVpnTunnelOptionsSpecification
tunnelOptions

instance Data.ToHeaders ModifyVpnTunnelOptions where
  toHeaders :: ModifyVpnTunnelOptions -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance Data.ToPath ModifyVpnTunnelOptions where
  toPath :: ModifyVpnTunnelOptions -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery ModifyVpnTunnelOptions where
  toQuery :: ModifyVpnTunnelOptions -> QueryString
toQuery ModifyVpnTunnelOptions' {Maybe Bool
Text
ModifyVpnTunnelOptionsSpecification
tunnelOptions :: ModifyVpnTunnelOptionsSpecification
vpnTunnelOutsideIpAddress :: Text
vpnConnectionId :: Text
dryRun :: Maybe Bool
$sel:tunnelOptions:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> ModifyVpnTunnelOptionsSpecification
$sel:vpnTunnelOutsideIpAddress:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Text
$sel:vpnConnectionId:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Text
$sel:dryRun:ModifyVpnTunnelOptions' :: ModifyVpnTunnelOptions -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"ModifyVpnTunnelOptions" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"VpnConnectionId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
vpnConnectionId,
        ByteString
"VpnTunnelOutsideIpAddress"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
vpnTunnelOutsideIpAddress,
        ByteString
"TunnelOptions" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ModifyVpnTunnelOptionsSpecification
tunnelOptions
      ]

-- | /See:/ 'newModifyVpnTunnelOptionsResponse' smart constructor.
data ModifyVpnTunnelOptionsResponse = ModifyVpnTunnelOptionsResponse'
  { -- | Information about the VPN connection.
    ModifyVpnTunnelOptionsResponse -> Maybe VpnConnection
vpnConnection :: Prelude.Maybe VpnConnection,
    -- | The response's http status code.
    ModifyVpnTunnelOptionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ModifyVpnTunnelOptionsResponse
-> ModifyVpnTunnelOptionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifyVpnTunnelOptionsResponse
-> ModifyVpnTunnelOptionsResponse -> Bool
$c/= :: ModifyVpnTunnelOptionsResponse
-> ModifyVpnTunnelOptionsResponse -> Bool
== :: ModifyVpnTunnelOptionsResponse
-> ModifyVpnTunnelOptionsResponse -> Bool
$c== :: ModifyVpnTunnelOptionsResponse
-> ModifyVpnTunnelOptionsResponse -> Bool
Prelude.Eq, ReadPrec [ModifyVpnTunnelOptionsResponse]
ReadPrec ModifyVpnTunnelOptionsResponse
Int -> ReadS ModifyVpnTunnelOptionsResponse
ReadS [ModifyVpnTunnelOptionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ModifyVpnTunnelOptionsResponse]
$creadListPrec :: ReadPrec [ModifyVpnTunnelOptionsResponse]
readPrec :: ReadPrec ModifyVpnTunnelOptionsResponse
$creadPrec :: ReadPrec ModifyVpnTunnelOptionsResponse
readList :: ReadS [ModifyVpnTunnelOptionsResponse]
$creadList :: ReadS [ModifyVpnTunnelOptionsResponse]
readsPrec :: Int -> ReadS ModifyVpnTunnelOptionsResponse
$creadsPrec :: Int -> ReadS ModifyVpnTunnelOptionsResponse
Prelude.Read, Int -> ModifyVpnTunnelOptionsResponse -> ShowS
[ModifyVpnTunnelOptionsResponse] -> ShowS
ModifyVpnTunnelOptionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifyVpnTunnelOptionsResponse] -> ShowS
$cshowList :: [ModifyVpnTunnelOptionsResponse] -> ShowS
show :: ModifyVpnTunnelOptionsResponse -> String
$cshow :: ModifyVpnTunnelOptionsResponse -> String
showsPrec :: Int -> ModifyVpnTunnelOptionsResponse -> ShowS
$cshowsPrec :: Int -> ModifyVpnTunnelOptionsResponse -> ShowS
Prelude.Show, forall x.
Rep ModifyVpnTunnelOptionsResponse x
-> ModifyVpnTunnelOptionsResponse
forall x.
ModifyVpnTunnelOptionsResponse
-> Rep ModifyVpnTunnelOptionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ModifyVpnTunnelOptionsResponse x
-> ModifyVpnTunnelOptionsResponse
$cfrom :: forall x.
ModifyVpnTunnelOptionsResponse
-> Rep ModifyVpnTunnelOptionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ModifyVpnTunnelOptionsResponse' 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:
--
-- 'vpnConnection', 'modifyVpnTunnelOptionsResponse_vpnConnection' - Information about the VPN connection.
--
-- 'httpStatus', 'modifyVpnTunnelOptionsResponse_httpStatus' - The response's http status code.
newModifyVpnTunnelOptionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ModifyVpnTunnelOptionsResponse
newModifyVpnTunnelOptionsResponse :: Int -> ModifyVpnTunnelOptionsResponse
newModifyVpnTunnelOptionsResponse Int
pHttpStatus_ =
  ModifyVpnTunnelOptionsResponse'
    { $sel:vpnConnection:ModifyVpnTunnelOptionsResponse' :: Maybe VpnConnection
vpnConnection =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ModifyVpnTunnelOptionsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the VPN connection.
modifyVpnTunnelOptionsResponse_vpnConnection :: Lens.Lens' ModifyVpnTunnelOptionsResponse (Prelude.Maybe VpnConnection)
modifyVpnTunnelOptionsResponse_vpnConnection :: Lens' ModifyVpnTunnelOptionsResponse (Maybe VpnConnection)
modifyVpnTunnelOptionsResponse_vpnConnection = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyVpnTunnelOptionsResponse' {Maybe VpnConnection
vpnConnection :: Maybe VpnConnection
$sel:vpnConnection:ModifyVpnTunnelOptionsResponse' :: ModifyVpnTunnelOptionsResponse -> Maybe VpnConnection
vpnConnection} -> Maybe VpnConnection
vpnConnection) (\s :: ModifyVpnTunnelOptionsResponse
s@ModifyVpnTunnelOptionsResponse' {} Maybe VpnConnection
a -> ModifyVpnTunnelOptionsResponse
s {$sel:vpnConnection:ModifyVpnTunnelOptionsResponse' :: Maybe VpnConnection
vpnConnection = Maybe VpnConnection
a} :: ModifyVpnTunnelOptionsResponse)

-- | The response's http status code.
modifyVpnTunnelOptionsResponse_httpStatus :: Lens.Lens' ModifyVpnTunnelOptionsResponse Prelude.Int
modifyVpnTunnelOptionsResponse_httpStatus :: Lens' ModifyVpnTunnelOptionsResponse Int
modifyVpnTunnelOptionsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ModifyVpnTunnelOptionsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ModifyVpnTunnelOptionsResponse' :: ModifyVpnTunnelOptionsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ModifyVpnTunnelOptionsResponse
s@ModifyVpnTunnelOptionsResponse' {} Int
a -> ModifyVpnTunnelOptionsResponse
s {$sel:httpStatus:ModifyVpnTunnelOptionsResponse' :: Int
httpStatus = Int
a} :: ModifyVpnTunnelOptionsResponse)

instance
  Prelude.NFData
    ModifyVpnTunnelOptionsResponse
  where
  rnf :: ModifyVpnTunnelOptionsResponse -> ()
rnf ModifyVpnTunnelOptionsResponse' {Int
Maybe VpnConnection
httpStatus :: Int
vpnConnection :: Maybe VpnConnection
$sel:httpStatus:ModifyVpnTunnelOptionsResponse' :: ModifyVpnTunnelOptionsResponse -> Int
$sel:vpnConnection:ModifyVpnTunnelOptionsResponse' :: ModifyVpnTunnelOptionsResponse -> Maybe VpnConnection
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe VpnConnection
vpnConnection
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus