{-# 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.IoTSecureTunneling.OpenTunnel
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a new tunnel, and returns two client access tokens for clients
-- to use to connect to the IoT Secure Tunneling proxy server.
--
-- Requires permission to access the
-- <https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions OpenTunnel>
-- action.
module Amazonka.IoTSecureTunneling.OpenTunnel
  ( -- * Creating a Request
    OpenTunnel (..),
    newOpenTunnel,

    -- * Request Lenses
    openTunnel_description,
    openTunnel_destinationConfig,
    openTunnel_tags,
    openTunnel_timeoutConfig,

    -- * Destructuring the Response
    OpenTunnelResponse (..),
    newOpenTunnelResponse,

    -- * Response Lenses
    openTunnelResponse_destinationAccessToken,
    openTunnelResponse_sourceAccessToken,
    openTunnelResponse_tunnelArn,
    openTunnelResponse_tunnelId,
    openTunnelResponse_httpStatus,
  )
where

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

-- | /See:/ 'newOpenTunnel' smart constructor.
data OpenTunnel = OpenTunnel'
  { -- | A short text description of the tunnel.
    OpenTunnel -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The destination configuration for the OpenTunnel request.
    OpenTunnel -> Maybe DestinationConfig
destinationConfig :: Prelude.Maybe DestinationConfig,
    -- | A collection of tag metadata.
    OpenTunnel -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    -- | Timeout configuration for a tunnel.
    OpenTunnel -> Maybe TimeoutConfig
timeoutConfig :: Prelude.Maybe TimeoutConfig
  }
  deriving (OpenTunnel -> OpenTunnel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OpenTunnel -> OpenTunnel -> Bool
$c/= :: OpenTunnel -> OpenTunnel -> Bool
== :: OpenTunnel -> OpenTunnel -> Bool
$c== :: OpenTunnel -> OpenTunnel -> Bool
Prelude.Eq, ReadPrec [OpenTunnel]
ReadPrec OpenTunnel
Int -> ReadS OpenTunnel
ReadS [OpenTunnel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OpenTunnel]
$creadListPrec :: ReadPrec [OpenTunnel]
readPrec :: ReadPrec OpenTunnel
$creadPrec :: ReadPrec OpenTunnel
readList :: ReadS [OpenTunnel]
$creadList :: ReadS [OpenTunnel]
readsPrec :: Int -> ReadS OpenTunnel
$creadsPrec :: Int -> ReadS OpenTunnel
Prelude.Read, Int -> OpenTunnel -> ShowS
[OpenTunnel] -> ShowS
OpenTunnel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OpenTunnel] -> ShowS
$cshowList :: [OpenTunnel] -> ShowS
show :: OpenTunnel -> String
$cshow :: OpenTunnel -> String
showsPrec :: Int -> OpenTunnel -> ShowS
$cshowsPrec :: Int -> OpenTunnel -> ShowS
Prelude.Show, forall x. Rep OpenTunnel x -> OpenTunnel
forall x. OpenTunnel -> Rep OpenTunnel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OpenTunnel x -> OpenTunnel
$cfrom :: forall x. OpenTunnel -> Rep OpenTunnel x
Prelude.Generic)

-- |
-- Create a value of 'OpenTunnel' 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:
--
-- 'description', 'openTunnel_description' - A short text description of the tunnel.
--
-- 'destinationConfig', 'openTunnel_destinationConfig' - The destination configuration for the OpenTunnel request.
--
-- 'tags', 'openTunnel_tags' - A collection of tag metadata.
--
-- 'timeoutConfig', 'openTunnel_timeoutConfig' - Timeout configuration for a tunnel.
newOpenTunnel ::
  OpenTunnel
newOpenTunnel :: OpenTunnel
newOpenTunnel =
  OpenTunnel'
    { $sel:description:OpenTunnel' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:destinationConfig:OpenTunnel' :: Maybe DestinationConfig
destinationConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:OpenTunnel' :: Maybe (NonEmpty Tag)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:timeoutConfig:OpenTunnel' :: Maybe TimeoutConfig
timeoutConfig = forall a. Maybe a
Prelude.Nothing
    }

-- | A short text description of the tunnel.
openTunnel_description :: Lens.Lens' OpenTunnel (Prelude.Maybe Prelude.Text)
openTunnel_description :: Lens' OpenTunnel (Maybe Text)
openTunnel_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnel' {Maybe Text
description :: Maybe Text
$sel:description:OpenTunnel' :: OpenTunnel -> Maybe Text
description} -> Maybe Text
description) (\s :: OpenTunnel
s@OpenTunnel' {} Maybe Text
a -> OpenTunnel
s {$sel:description:OpenTunnel' :: Maybe Text
description = Maybe Text
a} :: OpenTunnel)

-- | The destination configuration for the OpenTunnel request.
openTunnel_destinationConfig :: Lens.Lens' OpenTunnel (Prelude.Maybe DestinationConfig)
openTunnel_destinationConfig :: Lens' OpenTunnel (Maybe DestinationConfig)
openTunnel_destinationConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnel' {Maybe DestinationConfig
destinationConfig :: Maybe DestinationConfig
$sel:destinationConfig:OpenTunnel' :: OpenTunnel -> Maybe DestinationConfig
destinationConfig} -> Maybe DestinationConfig
destinationConfig) (\s :: OpenTunnel
s@OpenTunnel' {} Maybe DestinationConfig
a -> OpenTunnel
s {$sel:destinationConfig:OpenTunnel' :: Maybe DestinationConfig
destinationConfig = Maybe DestinationConfig
a} :: OpenTunnel)

-- | A collection of tag metadata.
openTunnel_tags :: Lens.Lens' OpenTunnel (Prelude.Maybe (Prelude.NonEmpty Tag))
openTunnel_tags :: Lens' OpenTunnel (Maybe (NonEmpty Tag))
openTunnel_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnel' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:OpenTunnel' :: OpenTunnel -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: OpenTunnel
s@OpenTunnel' {} Maybe (NonEmpty Tag)
a -> OpenTunnel
s {$sel:tags:OpenTunnel' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
a} :: OpenTunnel) 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

-- | Timeout configuration for a tunnel.
openTunnel_timeoutConfig :: Lens.Lens' OpenTunnel (Prelude.Maybe TimeoutConfig)
openTunnel_timeoutConfig :: Lens' OpenTunnel (Maybe TimeoutConfig)
openTunnel_timeoutConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnel' {Maybe TimeoutConfig
timeoutConfig :: Maybe TimeoutConfig
$sel:timeoutConfig:OpenTunnel' :: OpenTunnel -> Maybe TimeoutConfig
timeoutConfig} -> Maybe TimeoutConfig
timeoutConfig) (\s :: OpenTunnel
s@OpenTunnel' {} Maybe TimeoutConfig
a -> OpenTunnel
s {$sel:timeoutConfig:OpenTunnel' :: Maybe TimeoutConfig
timeoutConfig = Maybe TimeoutConfig
a} :: OpenTunnel)

instance Core.AWSRequest OpenTunnel where
  type AWSResponse OpenTunnel = OpenTunnelResponse
  request :: (Service -> Service) -> OpenTunnel -> Request OpenTunnel
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy OpenTunnel
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse OpenTunnel)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe (Sensitive Text)
-> Maybe (Sensitive Text)
-> Maybe Text
-> Maybe Text
-> Int
-> OpenTunnelResponse
OpenTunnelResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"destinationAccessToken")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"sourceAccessToken")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"tunnelArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"tunnelId")
            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 OpenTunnel where
  hashWithSalt :: Int -> OpenTunnel -> Int
hashWithSalt Int
_salt OpenTunnel' {Maybe (NonEmpty Tag)
Maybe Text
Maybe DestinationConfig
Maybe TimeoutConfig
timeoutConfig :: Maybe TimeoutConfig
tags :: Maybe (NonEmpty Tag)
destinationConfig :: Maybe DestinationConfig
description :: Maybe Text
$sel:timeoutConfig:OpenTunnel' :: OpenTunnel -> Maybe TimeoutConfig
$sel:tags:OpenTunnel' :: OpenTunnel -> Maybe (NonEmpty Tag)
$sel:destinationConfig:OpenTunnel' :: OpenTunnel -> Maybe DestinationConfig
$sel:description:OpenTunnel' :: OpenTunnel -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DestinationConfig
destinationConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Tag)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TimeoutConfig
timeoutConfig

instance Prelude.NFData OpenTunnel where
  rnf :: OpenTunnel -> ()
rnf OpenTunnel' {Maybe (NonEmpty Tag)
Maybe Text
Maybe DestinationConfig
Maybe TimeoutConfig
timeoutConfig :: Maybe TimeoutConfig
tags :: Maybe (NonEmpty Tag)
destinationConfig :: Maybe DestinationConfig
description :: Maybe Text
$sel:timeoutConfig:OpenTunnel' :: OpenTunnel -> Maybe TimeoutConfig
$sel:tags:OpenTunnel' :: OpenTunnel -> Maybe (NonEmpty Tag)
$sel:destinationConfig:OpenTunnel' :: OpenTunnel -> Maybe DestinationConfig
$sel:description:OpenTunnel' :: OpenTunnel -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DestinationConfig
destinationConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Tag)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TimeoutConfig
timeoutConfig

instance Data.ToHeaders OpenTunnel where
  toHeaders :: OpenTunnel -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"IoTSecuredTunneling.OpenTunnel" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON OpenTunnel where
  toJSON :: OpenTunnel -> Value
toJSON OpenTunnel' {Maybe (NonEmpty Tag)
Maybe Text
Maybe DestinationConfig
Maybe TimeoutConfig
timeoutConfig :: Maybe TimeoutConfig
tags :: Maybe (NonEmpty Tag)
destinationConfig :: Maybe DestinationConfig
description :: Maybe Text
$sel:timeoutConfig:OpenTunnel' :: OpenTunnel -> Maybe TimeoutConfig
$sel:tags:OpenTunnel' :: OpenTunnel -> Maybe (NonEmpty Tag)
$sel:destinationConfig:OpenTunnel' :: OpenTunnel -> Maybe DestinationConfig
$sel:description:OpenTunnel' :: OpenTunnel -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Key
"destinationConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DestinationConfig
destinationConfig,
            (Key
"tags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty Tag)
tags,
            (Key
"timeoutConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe TimeoutConfig
timeoutConfig
          ]
      )

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

instance Data.ToQuery OpenTunnel where
  toQuery :: OpenTunnel -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newOpenTunnelResponse' smart constructor.
data OpenTunnelResponse = OpenTunnelResponse'
  { -- | The access token the destination local proxy uses to connect to IoT
    -- Secure Tunneling.
    OpenTunnelResponse -> Maybe (Sensitive Text)
destinationAccessToken :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | The access token the source local proxy uses to connect to IoT Secure
    -- Tunneling.
    OpenTunnelResponse -> Maybe (Sensitive Text)
sourceAccessToken :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | The Amazon Resource Name for the tunnel.
    OpenTunnelResponse -> Maybe Text
tunnelArn :: Prelude.Maybe Prelude.Text,
    -- | A unique alpha-numeric tunnel ID.
    OpenTunnelResponse -> Maybe Text
tunnelId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    OpenTunnelResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (OpenTunnelResponse -> OpenTunnelResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OpenTunnelResponse -> OpenTunnelResponse -> Bool
$c/= :: OpenTunnelResponse -> OpenTunnelResponse -> Bool
== :: OpenTunnelResponse -> OpenTunnelResponse -> Bool
$c== :: OpenTunnelResponse -> OpenTunnelResponse -> Bool
Prelude.Eq, Int -> OpenTunnelResponse -> ShowS
[OpenTunnelResponse] -> ShowS
OpenTunnelResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OpenTunnelResponse] -> ShowS
$cshowList :: [OpenTunnelResponse] -> ShowS
show :: OpenTunnelResponse -> String
$cshow :: OpenTunnelResponse -> String
showsPrec :: Int -> OpenTunnelResponse -> ShowS
$cshowsPrec :: Int -> OpenTunnelResponse -> ShowS
Prelude.Show, forall x. Rep OpenTunnelResponse x -> OpenTunnelResponse
forall x. OpenTunnelResponse -> Rep OpenTunnelResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OpenTunnelResponse x -> OpenTunnelResponse
$cfrom :: forall x. OpenTunnelResponse -> Rep OpenTunnelResponse x
Prelude.Generic)

-- |
-- Create a value of 'OpenTunnelResponse' 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:
--
-- 'destinationAccessToken', 'openTunnelResponse_destinationAccessToken' - The access token the destination local proxy uses to connect to IoT
-- Secure Tunneling.
--
-- 'sourceAccessToken', 'openTunnelResponse_sourceAccessToken' - The access token the source local proxy uses to connect to IoT Secure
-- Tunneling.
--
-- 'tunnelArn', 'openTunnelResponse_tunnelArn' - The Amazon Resource Name for the tunnel.
--
-- 'tunnelId', 'openTunnelResponse_tunnelId' - A unique alpha-numeric tunnel ID.
--
-- 'httpStatus', 'openTunnelResponse_httpStatus' - The response's http status code.
newOpenTunnelResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  OpenTunnelResponse
newOpenTunnelResponse :: Int -> OpenTunnelResponse
newOpenTunnelResponse Int
pHttpStatus_ =
  OpenTunnelResponse'
    { $sel:destinationAccessToken:OpenTunnelResponse' :: Maybe (Sensitive Text)
destinationAccessToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:sourceAccessToken:OpenTunnelResponse' :: Maybe (Sensitive Text)
sourceAccessToken = forall a. Maybe a
Prelude.Nothing,
      $sel:tunnelArn:OpenTunnelResponse' :: Maybe Text
tunnelArn = forall a. Maybe a
Prelude.Nothing,
      $sel:tunnelId:OpenTunnelResponse' :: Maybe Text
tunnelId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:OpenTunnelResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The access token the destination local proxy uses to connect to IoT
-- Secure Tunneling.
openTunnelResponse_destinationAccessToken :: Lens.Lens' OpenTunnelResponse (Prelude.Maybe Prelude.Text)
openTunnelResponse_destinationAccessToken :: Lens' OpenTunnelResponse (Maybe Text)
openTunnelResponse_destinationAccessToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnelResponse' {Maybe (Sensitive Text)
destinationAccessToken :: Maybe (Sensitive Text)
$sel:destinationAccessToken:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe (Sensitive Text)
destinationAccessToken} -> Maybe (Sensitive Text)
destinationAccessToken) (\s :: OpenTunnelResponse
s@OpenTunnelResponse' {} Maybe (Sensitive Text)
a -> OpenTunnelResponse
s {$sel:destinationAccessToken:OpenTunnelResponse' :: Maybe (Sensitive Text)
destinationAccessToken = Maybe (Sensitive Text)
a} :: OpenTunnelResponse) 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 a. Iso' (Sensitive a) a
Data._Sensitive

-- | The access token the source local proxy uses to connect to IoT Secure
-- Tunneling.
openTunnelResponse_sourceAccessToken :: Lens.Lens' OpenTunnelResponse (Prelude.Maybe Prelude.Text)
openTunnelResponse_sourceAccessToken :: Lens' OpenTunnelResponse (Maybe Text)
openTunnelResponse_sourceAccessToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnelResponse' {Maybe (Sensitive Text)
sourceAccessToken :: Maybe (Sensitive Text)
$sel:sourceAccessToken:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe (Sensitive Text)
sourceAccessToken} -> Maybe (Sensitive Text)
sourceAccessToken) (\s :: OpenTunnelResponse
s@OpenTunnelResponse' {} Maybe (Sensitive Text)
a -> OpenTunnelResponse
s {$sel:sourceAccessToken:OpenTunnelResponse' :: Maybe (Sensitive Text)
sourceAccessToken = Maybe (Sensitive Text)
a} :: OpenTunnelResponse) 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 a. Iso' (Sensitive a) a
Data._Sensitive

-- | The Amazon Resource Name for the tunnel.
openTunnelResponse_tunnelArn :: Lens.Lens' OpenTunnelResponse (Prelude.Maybe Prelude.Text)
openTunnelResponse_tunnelArn :: Lens' OpenTunnelResponse (Maybe Text)
openTunnelResponse_tunnelArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnelResponse' {Maybe Text
tunnelArn :: Maybe Text
$sel:tunnelArn:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe Text
tunnelArn} -> Maybe Text
tunnelArn) (\s :: OpenTunnelResponse
s@OpenTunnelResponse' {} Maybe Text
a -> OpenTunnelResponse
s {$sel:tunnelArn:OpenTunnelResponse' :: Maybe Text
tunnelArn = Maybe Text
a} :: OpenTunnelResponse)

-- | A unique alpha-numeric tunnel ID.
openTunnelResponse_tunnelId :: Lens.Lens' OpenTunnelResponse (Prelude.Maybe Prelude.Text)
openTunnelResponse_tunnelId :: Lens' OpenTunnelResponse (Maybe Text)
openTunnelResponse_tunnelId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\OpenTunnelResponse' {Maybe Text
tunnelId :: Maybe Text
$sel:tunnelId:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe Text
tunnelId} -> Maybe Text
tunnelId) (\s :: OpenTunnelResponse
s@OpenTunnelResponse' {} Maybe Text
a -> OpenTunnelResponse
s {$sel:tunnelId:OpenTunnelResponse' :: Maybe Text
tunnelId = Maybe Text
a} :: OpenTunnelResponse)

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

instance Prelude.NFData OpenTunnelResponse where
  rnf :: OpenTunnelResponse -> ()
rnf OpenTunnelResponse' {Int
Maybe Text
Maybe (Sensitive Text)
httpStatus :: Int
tunnelId :: Maybe Text
tunnelArn :: Maybe Text
sourceAccessToken :: Maybe (Sensitive Text)
destinationAccessToken :: Maybe (Sensitive Text)
$sel:httpStatus:OpenTunnelResponse' :: OpenTunnelResponse -> Int
$sel:tunnelId:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe Text
$sel:tunnelArn:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe Text
$sel:sourceAccessToken:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe (Sensitive Text)
$sel:destinationAccessToken:OpenTunnelResponse' :: OpenTunnelResponse -> Maybe (Sensitive Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
destinationAccessToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
sourceAccessToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
tunnelArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
tunnelId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus