{-# 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.NetworkManager.CreateConnectPeer
-- 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 core network Connect peer for a specified core network connect
-- attachment between a core network and an appliance. The peer address and
-- transit gateway address must be the same IP address family (IPv4 or
-- IPv6).
module Amazonka.NetworkManager.CreateConnectPeer
  ( -- * Creating a Request
    CreateConnectPeer (..),
    newCreateConnectPeer,

    -- * Request Lenses
    createConnectPeer_bgpOptions,
    createConnectPeer_clientToken,
    createConnectPeer_coreNetworkAddress,
    createConnectPeer_tags,
    createConnectPeer_connectAttachmentId,
    createConnectPeer_peerAddress,
    createConnectPeer_insideCidrBlocks,

    -- * Destructuring the Response
    CreateConnectPeerResponse (..),
    newCreateConnectPeerResponse,

    -- * Response Lenses
    createConnectPeerResponse_connectPeer,
    createConnectPeerResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateConnectPeer' smart constructor.
data CreateConnectPeer = CreateConnectPeer'
  { -- | The Connect peer BGP options.
    CreateConnectPeer -> Maybe BgpOptions
bgpOptions :: Prelude.Maybe BgpOptions,
    -- | The client token associated with the request.
    CreateConnectPeer -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | A Connect peer core network address.
    CreateConnectPeer -> Maybe Text
coreNetworkAddress :: Prelude.Maybe Prelude.Text,
    -- | The tags associated with the peer request.
    CreateConnectPeer -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The ID of the connection attachment.
    CreateConnectPeer -> Text
connectAttachmentId :: Prelude.Text,
    -- | The Connect peer address.
    CreateConnectPeer -> Text
peerAddress :: Prelude.Text,
    -- | The inside IP addresses used for BGP peering.
    CreateConnectPeer -> [Text]
insideCidrBlocks :: [Prelude.Text]
  }
  deriving (CreateConnectPeer -> CreateConnectPeer -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateConnectPeer -> CreateConnectPeer -> Bool
$c/= :: CreateConnectPeer -> CreateConnectPeer -> Bool
== :: CreateConnectPeer -> CreateConnectPeer -> Bool
$c== :: CreateConnectPeer -> CreateConnectPeer -> Bool
Prelude.Eq, ReadPrec [CreateConnectPeer]
ReadPrec CreateConnectPeer
Int -> ReadS CreateConnectPeer
ReadS [CreateConnectPeer]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateConnectPeer]
$creadListPrec :: ReadPrec [CreateConnectPeer]
readPrec :: ReadPrec CreateConnectPeer
$creadPrec :: ReadPrec CreateConnectPeer
readList :: ReadS [CreateConnectPeer]
$creadList :: ReadS [CreateConnectPeer]
readsPrec :: Int -> ReadS CreateConnectPeer
$creadsPrec :: Int -> ReadS CreateConnectPeer
Prelude.Read, Int -> CreateConnectPeer -> ShowS
[CreateConnectPeer] -> ShowS
CreateConnectPeer -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateConnectPeer] -> ShowS
$cshowList :: [CreateConnectPeer] -> ShowS
show :: CreateConnectPeer -> String
$cshow :: CreateConnectPeer -> String
showsPrec :: Int -> CreateConnectPeer -> ShowS
$cshowsPrec :: Int -> CreateConnectPeer -> ShowS
Prelude.Show, forall x. Rep CreateConnectPeer x -> CreateConnectPeer
forall x. CreateConnectPeer -> Rep CreateConnectPeer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateConnectPeer x -> CreateConnectPeer
$cfrom :: forall x. CreateConnectPeer -> Rep CreateConnectPeer x
Prelude.Generic)

-- |
-- Create a value of 'CreateConnectPeer' 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:
--
-- 'bgpOptions', 'createConnectPeer_bgpOptions' - The Connect peer BGP options.
--
-- 'clientToken', 'createConnectPeer_clientToken' - The client token associated with the request.
--
-- 'coreNetworkAddress', 'createConnectPeer_coreNetworkAddress' - A Connect peer core network address.
--
-- 'tags', 'createConnectPeer_tags' - The tags associated with the peer request.
--
-- 'connectAttachmentId', 'createConnectPeer_connectAttachmentId' - The ID of the connection attachment.
--
-- 'peerAddress', 'createConnectPeer_peerAddress' - The Connect peer address.
--
-- 'insideCidrBlocks', 'createConnectPeer_insideCidrBlocks' - The inside IP addresses used for BGP peering.
newCreateConnectPeer ::
  -- | 'connectAttachmentId'
  Prelude.Text ->
  -- | 'peerAddress'
  Prelude.Text ->
  CreateConnectPeer
newCreateConnectPeer :: Text -> Text -> CreateConnectPeer
newCreateConnectPeer
  Text
pConnectAttachmentId_
  Text
pPeerAddress_ =
    CreateConnectPeer'
      { $sel:bgpOptions:CreateConnectPeer' :: Maybe BgpOptions
bgpOptions = forall a. Maybe a
Prelude.Nothing,
        $sel:clientToken:CreateConnectPeer' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
        $sel:coreNetworkAddress:CreateConnectPeer' :: Maybe Text
coreNetworkAddress = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateConnectPeer' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:connectAttachmentId:CreateConnectPeer' :: Text
connectAttachmentId = Text
pConnectAttachmentId_,
        $sel:peerAddress:CreateConnectPeer' :: Text
peerAddress = Text
pPeerAddress_,
        $sel:insideCidrBlocks:CreateConnectPeer' :: [Text]
insideCidrBlocks = forall a. Monoid a => a
Prelude.mempty
      }

-- | The Connect peer BGP options.
createConnectPeer_bgpOptions :: Lens.Lens' CreateConnectPeer (Prelude.Maybe BgpOptions)
createConnectPeer_bgpOptions :: Lens' CreateConnectPeer (Maybe BgpOptions)
createConnectPeer_bgpOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeer' {Maybe BgpOptions
bgpOptions :: Maybe BgpOptions
$sel:bgpOptions:CreateConnectPeer' :: CreateConnectPeer -> Maybe BgpOptions
bgpOptions} -> Maybe BgpOptions
bgpOptions) (\s :: CreateConnectPeer
s@CreateConnectPeer' {} Maybe BgpOptions
a -> CreateConnectPeer
s {$sel:bgpOptions:CreateConnectPeer' :: Maybe BgpOptions
bgpOptions = Maybe BgpOptions
a} :: CreateConnectPeer)

-- | The client token associated with the request.
createConnectPeer_clientToken :: Lens.Lens' CreateConnectPeer (Prelude.Maybe Prelude.Text)
createConnectPeer_clientToken :: Lens' CreateConnectPeer (Maybe Text)
createConnectPeer_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeer' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateConnectPeer
s@CreateConnectPeer' {} Maybe Text
a -> CreateConnectPeer
s {$sel:clientToken:CreateConnectPeer' :: Maybe Text
clientToken = Maybe Text
a} :: CreateConnectPeer)

-- | A Connect peer core network address.
createConnectPeer_coreNetworkAddress :: Lens.Lens' CreateConnectPeer (Prelude.Maybe Prelude.Text)
createConnectPeer_coreNetworkAddress :: Lens' CreateConnectPeer (Maybe Text)
createConnectPeer_coreNetworkAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeer' {Maybe Text
coreNetworkAddress :: Maybe Text
$sel:coreNetworkAddress:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
coreNetworkAddress} -> Maybe Text
coreNetworkAddress) (\s :: CreateConnectPeer
s@CreateConnectPeer' {} Maybe Text
a -> CreateConnectPeer
s {$sel:coreNetworkAddress:CreateConnectPeer' :: Maybe Text
coreNetworkAddress = Maybe Text
a} :: CreateConnectPeer)

-- | The tags associated with the peer request.
createConnectPeer_tags :: Lens.Lens' CreateConnectPeer (Prelude.Maybe [Tag])
createConnectPeer_tags :: Lens' CreateConnectPeer (Maybe [Tag])
createConnectPeer_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeer' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateConnectPeer' :: CreateConnectPeer -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateConnectPeer
s@CreateConnectPeer' {} Maybe [Tag]
a -> CreateConnectPeer
s {$sel:tags:CreateConnectPeer' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateConnectPeer) 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 ID of the connection attachment.
createConnectPeer_connectAttachmentId :: Lens.Lens' CreateConnectPeer Prelude.Text
createConnectPeer_connectAttachmentId :: Lens' CreateConnectPeer Text
createConnectPeer_connectAttachmentId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeer' {Text
connectAttachmentId :: Text
$sel:connectAttachmentId:CreateConnectPeer' :: CreateConnectPeer -> Text
connectAttachmentId} -> Text
connectAttachmentId) (\s :: CreateConnectPeer
s@CreateConnectPeer' {} Text
a -> CreateConnectPeer
s {$sel:connectAttachmentId:CreateConnectPeer' :: Text
connectAttachmentId = Text
a} :: CreateConnectPeer)

-- | The Connect peer address.
createConnectPeer_peerAddress :: Lens.Lens' CreateConnectPeer Prelude.Text
createConnectPeer_peerAddress :: Lens' CreateConnectPeer Text
createConnectPeer_peerAddress = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeer' {Text
peerAddress :: Text
$sel:peerAddress:CreateConnectPeer' :: CreateConnectPeer -> Text
peerAddress} -> Text
peerAddress) (\s :: CreateConnectPeer
s@CreateConnectPeer' {} Text
a -> CreateConnectPeer
s {$sel:peerAddress:CreateConnectPeer' :: Text
peerAddress = Text
a} :: CreateConnectPeer)

-- | The inside IP addresses used for BGP peering.
createConnectPeer_insideCidrBlocks :: Lens.Lens' CreateConnectPeer [Prelude.Text]
createConnectPeer_insideCidrBlocks :: Lens' CreateConnectPeer [Text]
createConnectPeer_insideCidrBlocks = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeer' {[Text]
insideCidrBlocks :: [Text]
$sel:insideCidrBlocks:CreateConnectPeer' :: CreateConnectPeer -> [Text]
insideCidrBlocks} -> [Text]
insideCidrBlocks) (\s :: CreateConnectPeer
s@CreateConnectPeer' {} [Text]
a -> CreateConnectPeer
s {$sel:insideCidrBlocks:CreateConnectPeer' :: [Text]
insideCidrBlocks = [Text]
a} :: CreateConnectPeer) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest CreateConnectPeer where
  type
    AWSResponse CreateConnectPeer =
      CreateConnectPeerResponse
  request :: (Service -> Service)
-> CreateConnectPeer -> Request CreateConnectPeer
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 CreateConnectPeer
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateConnectPeer)))
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 ConnectPeer -> Int -> CreateConnectPeerResponse
CreateConnectPeerResponse'
            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
"ConnectPeer")
            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 CreateConnectPeer where
  hashWithSalt :: Int -> CreateConnectPeer -> Int
hashWithSalt Int
_salt CreateConnectPeer' {[Text]
Maybe [Tag]
Maybe Text
Maybe BgpOptions
Text
insideCidrBlocks :: [Text]
peerAddress :: Text
connectAttachmentId :: Text
tags :: Maybe [Tag]
coreNetworkAddress :: Maybe Text
clientToken :: Maybe Text
bgpOptions :: Maybe BgpOptions
$sel:insideCidrBlocks:CreateConnectPeer' :: CreateConnectPeer -> [Text]
$sel:peerAddress:CreateConnectPeer' :: CreateConnectPeer -> Text
$sel:connectAttachmentId:CreateConnectPeer' :: CreateConnectPeer -> Text
$sel:tags:CreateConnectPeer' :: CreateConnectPeer -> Maybe [Tag]
$sel:coreNetworkAddress:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
$sel:clientToken:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
$sel:bgpOptions:CreateConnectPeer' :: CreateConnectPeer -> Maybe BgpOptions
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe BgpOptions
bgpOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
coreNetworkAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
connectAttachmentId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
peerAddress
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
insideCidrBlocks

instance Prelude.NFData CreateConnectPeer where
  rnf :: CreateConnectPeer -> ()
rnf CreateConnectPeer' {[Text]
Maybe [Tag]
Maybe Text
Maybe BgpOptions
Text
insideCidrBlocks :: [Text]
peerAddress :: Text
connectAttachmentId :: Text
tags :: Maybe [Tag]
coreNetworkAddress :: Maybe Text
clientToken :: Maybe Text
bgpOptions :: Maybe BgpOptions
$sel:insideCidrBlocks:CreateConnectPeer' :: CreateConnectPeer -> [Text]
$sel:peerAddress:CreateConnectPeer' :: CreateConnectPeer -> Text
$sel:connectAttachmentId:CreateConnectPeer' :: CreateConnectPeer -> Text
$sel:tags:CreateConnectPeer' :: CreateConnectPeer -> Maybe [Tag]
$sel:coreNetworkAddress:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
$sel:clientToken:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
$sel:bgpOptions:CreateConnectPeer' :: CreateConnectPeer -> Maybe BgpOptions
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe BgpOptions
bgpOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
coreNetworkAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
connectAttachmentId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
peerAddress
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
insideCidrBlocks

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

instance Data.ToJSON CreateConnectPeer where
  toJSON :: CreateConnectPeer -> Value
toJSON CreateConnectPeer' {[Text]
Maybe [Tag]
Maybe Text
Maybe BgpOptions
Text
insideCidrBlocks :: [Text]
peerAddress :: Text
connectAttachmentId :: Text
tags :: Maybe [Tag]
coreNetworkAddress :: Maybe Text
clientToken :: Maybe Text
bgpOptions :: Maybe BgpOptions
$sel:insideCidrBlocks:CreateConnectPeer' :: CreateConnectPeer -> [Text]
$sel:peerAddress:CreateConnectPeer' :: CreateConnectPeer -> Text
$sel:connectAttachmentId:CreateConnectPeer' :: CreateConnectPeer -> Text
$sel:tags:CreateConnectPeer' :: CreateConnectPeer -> Maybe [Tag]
$sel:coreNetworkAddress:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
$sel:clientToken:CreateConnectPeer' :: CreateConnectPeer -> Maybe Text
$sel:bgpOptions:CreateConnectPeer' :: CreateConnectPeer -> Maybe BgpOptions
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"BgpOptions" 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 BgpOptions
bgpOptions,
            (Key
"ClientToken" 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
clientToken,
            (Key
"CoreNetworkAddress" 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
coreNetworkAddress,
            (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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ConnectAttachmentId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
connectAttachmentId),
            forall a. a -> Maybe a
Prelude.Just (Key
"PeerAddress" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
peerAddress),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"InsideCidrBlocks" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Text]
insideCidrBlocks)
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateConnectPeerResponse' 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:
--
-- 'connectPeer', 'createConnectPeerResponse_connectPeer' - The response to the request.
--
-- 'httpStatus', 'createConnectPeerResponse_httpStatus' - The response's http status code.
newCreateConnectPeerResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateConnectPeerResponse
newCreateConnectPeerResponse :: Int -> CreateConnectPeerResponse
newCreateConnectPeerResponse Int
pHttpStatus_ =
  CreateConnectPeerResponse'
    { $sel:connectPeer:CreateConnectPeerResponse' :: Maybe ConnectPeer
connectPeer =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateConnectPeerResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The response to the request.
createConnectPeerResponse_connectPeer :: Lens.Lens' CreateConnectPeerResponse (Prelude.Maybe ConnectPeer)
createConnectPeerResponse_connectPeer :: Lens' CreateConnectPeerResponse (Maybe ConnectPeer)
createConnectPeerResponse_connectPeer = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateConnectPeerResponse' {Maybe ConnectPeer
connectPeer :: Maybe ConnectPeer
$sel:connectPeer:CreateConnectPeerResponse' :: CreateConnectPeerResponse -> Maybe ConnectPeer
connectPeer} -> Maybe ConnectPeer
connectPeer) (\s :: CreateConnectPeerResponse
s@CreateConnectPeerResponse' {} Maybe ConnectPeer
a -> CreateConnectPeerResponse
s {$sel:connectPeer:CreateConnectPeerResponse' :: Maybe ConnectPeer
connectPeer = Maybe ConnectPeer
a} :: CreateConnectPeerResponse)

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

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