{-# 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.CloudWatchEvents.CreateConnection
-- 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 connection. A connection defines the authorization type and
-- credentials to use for authorization with an API destination HTTP
-- endpoint.
module Amazonka.CloudWatchEvents.CreateConnection
  ( -- * Creating a Request
    CreateConnection (..),
    newCreateConnection,

    -- * Request Lenses
    createConnection_description,
    createConnection_name,
    createConnection_authorizationType,
    createConnection_authParameters,

    -- * Destructuring the Response
    CreateConnectionResponse (..),
    newCreateConnectionResponse,

    -- * Response Lenses
    createConnectionResponse_connectionArn,
    createConnectionResponse_connectionState,
    createConnectionResponse_creationTime,
    createConnectionResponse_lastModifiedTime,
    createConnectionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateConnection' smart constructor.
data CreateConnection = CreateConnection'
  { -- | A description for the connection to create.
    CreateConnection -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The name for the connection to create.
    CreateConnection -> Text
name :: Prelude.Text,
    -- | The type of authorization to use for the connection.
    CreateConnection -> ConnectionAuthorizationType
authorizationType :: ConnectionAuthorizationType,
    -- | A @CreateConnectionAuthRequestParameters@ object that contains the
    -- authorization parameters to use to authorize with the endpoint.
    CreateConnection -> CreateConnectionAuthRequestParameters
authParameters :: CreateConnectionAuthRequestParameters
  }
  deriving (CreateConnection -> CreateConnection -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateConnection -> CreateConnection -> Bool
$c/= :: CreateConnection -> CreateConnection -> Bool
== :: CreateConnection -> CreateConnection -> Bool
$c== :: CreateConnection -> CreateConnection -> Bool
Prelude.Eq, ReadPrec [CreateConnection]
ReadPrec CreateConnection
Int -> ReadS CreateConnection
ReadS [CreateConnection]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateConnection]
$creadListPrec :: ReadPrec [CreateConnection]
readPrec :: ReadPrec CreateConnection
$creadPrec :: ReadPrec CreateConnection
readList :: ReadS [CreateConnection]
$creadList :: ReadS [CreateConnection]
readsPrec :: Int -> ReadS CreateConnection
$creadsPrec :: Int -> ReadS CreateConnection
Prelude.Read, Int -> CreateConnection -> ShowS
[CreateConnection] -> ShowS
CreateConnection -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateConnection] -> ShowS
$cshowList :: [CreateConnection] -> ShowS
show :: CreateConnection -> String
$cshow :: CreateConnection -> String
showsPrec :: Int -> CreateConnection -> ShowS
$cshowsPrec :: Int -> CreateConnection -> ShowS
Prelude.Show, forall x. Rep CreateConnection x -> CreateConnection
forall x. CreateConnection -> Rep CreateConnection x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateConnection x -> CreateConnection
$cfrom :: forall x. CreateConnection -> Rep CreateConnection x
Prelude.Generic)

-- |
-- Create a value of 'CreateConnection' 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', 'createConnection_description' - A description for the connection to create.
--
-- 'name', 'createConnection_name' - The name for the connection to create.
--
-- 'authorizationType', 'createConnection_authorizationType' - The type of authorization to use for the connection.
--
-- 'authParameters', 'createConnection_authParameters' - A @CreateConnectionAuthRequestParameters@ object that contains the
-- authorization parameters to use to authorize with the endpoint.
newCreateConnection ::
  -- | 'name'
  Prelude.Text ->
  -- | 'authorizationType'
  ConnectionAuthorizationType ->
  -- | 'authParameters'
  CreateConnectionAuthRequestParameters ->
  CreateConnection
newCreateConnection :: Text
-> ConnectionAuthorizationType
-> CreateConnectionAuthRequestParameters
-> CreateConnection
newCreateConnection
  Text
pName_
  ConnectionAuthorizationType
pAuthorizationType_
  CreateConnectionAuthRequestParameters
pAuthParameters_ =
    CreateConnection'
      { $sel:description:CreateConnection' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
        $sel:name:CreateConnection' :: Text
name = Text
pName_,
        $sel:authorizationType:CreateConnection' :: ConnectionAuthorizationType
authorizationType = ConnectionAuthorizationType
pAuthorizationType_,
        $sel:authParameters:CreateConnection' :: CreateConnectionAuthRequestParameters
authParameters = CreateConnectionAuthRequestParameters
pAuthParameters_
      }

-- | A description for the connection to create.
createConnection_description :: Lens.Lens' CreateConnection (Prelude.Maybe Prelude.Text)
createConnection_description :: Lens' CreateConnection (Maybe Text)
createConnection_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnection' {Maybe Text
description :: Maybe Text
$sel:description:CreateConnection' :: CreateConnection -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateConnection
s@CreateConnection' {} Maybe Text
a -> CreateConnection
s {$sel:description:CreateConnection' :: Maybe Text
description = Maybe Text
a} :: CreateConnection)

-- | The name for the connection to create.
createConnection_name :: Lens.Lens' CreateConnection Prelude.Text
createConnection_name :: Lens' CreateConnection Text
createConnection_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnection' {Text
name :: Text
$sel:name:CreateConnection' :: CreateConnection -> Text
name} -> Text
name) (\s :: CreateConnection
s@CreateConnection' {} Text
a -> CreateConnection
s {$sel:name:CreateConnection' :: Text
name = Text
a} :: CreateConnection)

-- | The type of authorization to use for the connection.
createConnection_authorizationType :: Lens.Lens' CreateConnection ConnectionAuthorizationType
createConnection_authorizationType :: Lens' CreateConnection ConnectionAuthorizationType
createConnection_authorizationType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnection' {ConnectionAuthorizationType
authorizationType :: ConnectionAuthorizationType
$sel:authorizationType:CreateConnection' :: CreateConnection -> ConnectionAuthorizationType
authorizationType} -> ConnectionAuthorizationType
authorizationType) (\s :: CreateConnection
s@CreateConnection' {} ConnectionAuthorizationType
a -> CreateConnection
s {$sel:authorizationType:CreateConnection' :: ConnectionAuthorizationType
authorizationType = ConnectionAuthorizationType
a} :: CreateConnection)

-- | A @CreateConnectionAuthRequestParameters@ object that contains the
-- authorization parameters to use to authorize with the endpoint.
createConnection_authParameters :: Lens.Lens' CreateConnection CreateConnectionAuthRequestParameters
createConnection_authParameters :: Lens' CreateConnection CreateConnectionAuthRequestParameters
createConnection_authParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnection' {CreateConnectionAuthRequestParameters
authParameters :: CreateConnectionAuthRequestParameters
$sel:authParameters:CreateConnection' :: CreateConnection -> CreateConnectionAuthRequestParameters
authParameters} -> CreateConnectionAuthRequestParameters
authParameters) (\s :: CreateConnection
s@CreateConnection' {} CreateConnectionAuthRequestParameters
a -> CreateConnection
s {$sel:authParameters:CreateConnection' :: CreateConnectionAuthRequestParameters
authParameters = CreateConnectionAuthRequestParameters
a} :: CreateConnection)

instance Core.AWSRequest CreateConnection where
  type
    AWSResponse CreateConnection =
      CreateConnectionResponse
  request :: (Service -> Service)
-> CreateConnection -> Request CreateConnection
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 CreateConnection
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateConnection)))
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 Text
-> Maybe ConnectionState
-> Maybe POSIX
-> Maybe POSIX
-> Int
-> CreateConnectionResponse
CreateConnectionResponse'
            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
"ConnectionArn")
            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
"ConnectionState")
            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
"CreationTime")
            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
"LastModifiedTime")
            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 CreateConnection where
  hashWithSalt :: Int -> CreateConnection -> Int
hashWithSalt Int
_salt CreateConnection' {Maybe Text
Text
ConnectionAuthorizationType
CreateConnectionAuthRequestParameters
authParameters :: CreateConnectionAuthRequestParameters
authorizationType :: ConnectionAuthorizationType
name :: Text
description :: Maybe Text
$sel:authParameters:CreateConnection' :: CreateConnection -> CreateConnectionAuthRequestParameters
$sel:authorizationType:CreateConnection' :: CreateConnection -> ConnectionAuthorizationType
$sel:name:CreateConnection' :: CreateConnection -> Text
$sel:description:CreateConnection' :: CreateConnection -> 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` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ConnectionAuthorizationType
authorizationType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` CreateConnectionAuthRequestParameters
authParameters

instance Prelude.NFData CreateConnection where
  rnf :: CreateConnection -> ()
rnf CreateConnection' {Maybe Text
Text
ConnectionAuthorizationType
CreateConnectionAuthRequestParameters
authParameters :: CreateConnectionAuthRequestParameters
authorizationType :: ConnectionAuthorizationType
name :: Text
description :: Maybe Text
$sel:authParameters:CreateConnection' :: CreateConnection -> CreateConnectionAuthRequestParameters
$sel:authorizationType:CreateConnection' :: CreateConnection -> ConnectionAuthorizationType
$sel:name:CreateConnection' :: CreateConnection -> Text
$sel:description:CreateConnection' :: CreateConnection -> 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 Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ConnectionAuthorizationType
authorizationType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf CreateConnectionAuthRequestParameters
authParameters

instance Data.ToHeaders CreateConnection where
  toHeaders :: CreateConnection -> 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
"AWSEvents.CreateConnection" :: 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 CreateConnection where
  toJSON :: CreateConnection -> Value
toJSON CreateConnection' {Maybe Text
Text
ConnectionAuthorizationType
CreateConnectionAuthRequestParameters
authParameters :: CreateConnectionAuthRequestParameters
authorizationType :: ConnectionAuthorizationType
name :: Text
description :: Maybe Text
$sel:authParameters:CreateConnection' :: CreateConnection -> CreateConnectionAuthRequestParameters
$sel:authorizationType:CreateConnection' :: CreateConnection -> ConnectionAuthorizationType
$sel:name:CreateConnection' :: CreateConnection -> Text
$sel:description:CreateConnection' :: CreateConnection -> 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,
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"AuthorizationType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ConnectionAuthorizationType
authorizationType),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"AuthParameters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= CreateConnectionAuthRequestParameters
authParameters)
          ]
      )

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

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

-- | /See:/ 'newCreateConnectionResponse' smart constructor.
data CreateConnectionResponse = CreateConnectionResponse'
  { -- | The ARN of the connection that was created by the request.
    CreateConnectionResponse -> Maybe Text
connectionArn :: Prelude.Maybe Prelude.Text,
    -- | The state of the connection that was created by the request.
    CreateConnectionResponse -> Maybe ConnectionState
connectionState :: Prelude.Maybe ConnectionState,
    -- | A time stamp for the time that the connection was created.
    CreateConnectionResponse -> Maybe POSIX
creationTime :: Prelude.Maybe Data.POSIX,
    -- | A time stamp for the time that the connection was last updated.
    CreateConnectionResponse -> Maybe POSIX
lastModifiedTime :: Prelude.Maybe Data.POSIX,
    -- | The response's http status code.
    CreateConnectionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateConnectionResponse -> CreateConnectionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateConnectionResponse -> CreateConnectionResponse -> Bool
$c/= :: CreateConnectionResponse -> CreateConnectionResponse -> Bool
== :: CreateConnectionResponse -> CreateConnectionResponse -> Bool
$c== :: CreateConnectionResponse -> CreateConnectionResponse -> Bool
Prelude.Eq, ReadPrec [CreateConnectionResponse]
ReadPrec CreateConnectionResponse
Int -> ReadS CreateConnectionResponse
ReadS [CreateConnectionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateConnectionResponse]
$creadListPrec :: ReadPrec [CreateConnectionResponse]
readPrec :: ReadPrec CreateConnectionResponse
$creadPrec :: ReadPrec CreateConnectionResponse
readList :: ReadS [CreateConnectionResponse]
$creadList :: ReadS [CreateConnectionResponse]
readsPrec :: Int -> ReadS CreateConnectionResponse
$creadsPrec :: Int -> ReadS CreateConnectionResponse
Prelude.Read, Int -> CreateConnectionResponse -> ShowS
[CreateConnectionResponse] -> ShowS
CreateConnectionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateConnectionResponse] -> ShowS
$cshowList :: [CreateConnectionResponse] -> ShowS
show :: CreateConnectionResponse -> String
$cshow :: CreateConnectionResponse -> String
showsPrec :: Int -> CreateConnectionResponse -> ShowS
$cshowsPrec :: Int -> CreateConnectionResponse -> ShowS
Prelude.Show, forall x.
Rep CreateConnectionResponse x -> CreateConnectionResponse
forall x.
CreateConnectionResponse -> Rep CreateConnectionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateConnectionResponse x -> CreateConnectionResponse
$cfrom :: forall x.
CreateConnectionResponse -> Rep CreateConnectionResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateConnectionResponse' 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:
--
-- 'connectionArn', 'createConnectionResponse_connectionArn' - The ARN of the connection that was created by the request.
--
-- 'connectionState', 'createConnectionResponse_connectionState' - The state of the connection that was created by the request.
--
-- 'creationTime', 'createConnectionResponse_creationTime' - A time stamp for the time that the connection was created.
--
-- 'lastModifiedTime', 'createConnectionResponse_lastModifiedTime' - A time stamp for the time that the connection was last updated.
--
-- 'httpStatus', 'createConnectionResponse_httpStatus' - The response's http status code.
newCreateConnectionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateConnectionResponse
newCreateConnectionResponse :: Int -> CreateConnectionResponse
newCreateConnectionResponse Int
pHttpStatus_ =
  CreateConnectionResponse'
    { $sel:connectionArn:CreateConnectionResponse' :: Maybe Text
connectionArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:connectionState:CreateConnectionResponse' :: Maybe ConnectionState
connectionState = forall a. Maybe a
Prelude.Nothing,
      $sel:creationTime:CreateConnectionResponse' :: Maybe POSIX
creationTime = forall a. Maybe a
Prelude.Nothing,
      $sel:lastModifiedTime:CreateConnectionResponse' :: Maybe POSIX
lastModifiedTime = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateConnectionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the connection that was created by the request.
createConnectionResponse_connectionArn :: Lens.Lens' CreateConnectionResponse (Prelude.Maybe Prelude.Text)
createConnectionResponse_connectionArn :: Lens' CreateConnectionResponse (Maybe Text)
createConnectionResponse_connectionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectionResponse' {Maybe Text
connectionArn :: Maybe Text
$sel:connectionArn:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe Text
connectionArn} -> Maybe Text
connectionArn) (\s :: CreateConnectionResponse
s@CreateConnectionResponse' {} Maybe Text
a -> CreateConnectionResponse
s {$sel:connectionArn:CreateConnectionResponse' :: Maybe Text
connectionArn = Maybe Text
a} :: CreateConnectionResponse)

-- | The state of the connection that was created by the request.
createConnectionResponse_connectionState :: Lens.Lens' CreateConnectionResponse (Prelude.Maybe ConnectionState)
createConnectionResponse_connectionState :: Lens' CreateConnectionResponse (Maybe ConnectionState)
createConnectionResponse_connectionState = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectionResponse' {Maybe ConnectionState
connectionState :: Maybe ConnectionState
$sel:connectionState:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe ConnectionState
connectionState} -> Maybe ConnectionState
connectionState) (\s :: CreateConnectionResponse
s@CreateConnectionResponse' {} Maybe ConnectionState
a -> CreateConnectionResponse
s {$sel:connectionState:CreateConnectionResponse' :: Maybe ConnectionState
connectionState = Maybe ConnectionState
a} :: CreateConnectionResponse)

-- | A time stamp for the time that the connection was created.
createConnectionResponse_creationTime :: Lens.Lens' CreateConnectionResponse (Prelude.Maybe Prelude.UTCTime)
createConnectionResponse_creationTime :: Lens' CreateConnectionResponse (Maybe UTCTime)
createConnectionResponse_creationTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectionResponse' {Maybe POSIX
creationTime :: Maybe POSIX
$sel:creationTime:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe POSIX
creationTime} -> Maybe POSIX
creationTime) (\s :: CreateConnectionResponse
s@CreateConnectionResponse' {} Maybe POSIX
a -> CreateConnectionResponse
s {$sel:creationTime:CreateConnectionResponse' :: Maybe POSIX
creationTime = Maybe POSIX
a} :: CreateConnectionResponse) 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 :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A time stamp for the time that the connection was last updated.
createConnectionResponse_lastModifiedTime :: Lens.Lens' CreateConnectionResponse (Prelude.Maybe Prelude.UTCTime)
createConnectionResponse_lastModifiedTime :: Lens' CreateConnectionResponse (Maybe UTCTime)
createConnectionResponse_lastModifiedTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectionResponse' {Maybe POSIX
lastModifiedTime :: Maybe POSIX
$sel:lastModifiedTime:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe POSIX
lastModifiedTime} -> Maybe POSIX
lastModifiedTime) (\s :: CreateConnectionResponse
s@CreateConnectionResponse' {} Maybe POSIX
a -> CreateConnectionResponse
s {$sel:lastModifiedTime:CreateConnectionResponse' :: Maybe POSIX
lastModifiedTime = Maybe POSIX
a} :: CreateConnectionResponse) 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 :: Format). Iso' (Time a) UTCTime
Data._Time

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

instance Prelude.NFData CreateConnectionResponse where
  rnf :: CreateConnectionResponse -> ()
rnf CreateConnectionResponse' {Int
Maybe Text
Maybe POSIX
Maybe ConnectionState
httpStatus :: Int
lastModifiedTime :: Maybe POSIX
creationTime :: Maybe POSIX
connectionState :: Maybe ConnectionState
connectionArn :: Maybe Text
$sel:httpStatus:CreateConnectionResponse' :: CreateConnectionResponse -> Int
$sel:lastModifiedTime:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe POSIX
$sel:creationTime:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe POSIX
$sel:connectionState:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe ConnectionState
$sel:connectionArn:CreateConnectionResponse' :: CreateConnectionResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
connectionArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ConnectionState
connectionState
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
creationTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastModifiedTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus