{-# 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.CreateCoreNetwork
-- 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 as part of your global network, and optionally,
-- with a core network policy.
module Amazonka.NetworkManager.CreateCoreNetwork
  ( -- * Creating a Request
    CreateCoreNetwork (..),
    newCreateCoreNetwork,

    -- * Request Lenses
    createCoreNetwork_clientToken,
    createCoreNetwork_description,
    createCoreNetwork_policyDocument,
    createCoreNetwork_tags,
    createCoreNetwork_globalNetworkId,

    -- * Destructuring the Response
    CreateCoreNetworkResponse (..),
    newCreateCoreNetworkResponse,

    -- * Response Lenses
    createCoreNetworkResponse_coreNetwork,
    createCoreNetworkResponse_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:/ 'newCreateCoreNetwork' smart constructor.
data CreateCoreNetwork = CreateCoreNetwork'
  { -- | The client token associated with a core network request.
    CreateCoreNetwork -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The description of a core network.
    CreateCoreNetwork -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The policy document for creating a core network.
    CreateCoreNetwork -> Maybe Text
policyDocument :: Prelude.Maybe Prelude.Text,
    -- | Key-value tags associated with a core network request.
    CreateCoreNetwork -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The ID of the global network that a core network will be a part of.
    CreateCoreNetwork -> Text
globalNetworkId :: Prelude.Text
  }
  deriving (CreateCoreNetwork -> CreateCoreNetwork -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCoreNetwork -> CreateCoreNetwork -> Bool
$c/= :: CreateCoreNetwork -> CreateCoreNetwork -> Bool
== :: CreateCoreNetwork -> CreateCoreNetwork -> Bool
$c== :: CreateCoreNetwork -> CreateCoreNetwork -> Bool
Prelude.Eq, ReadPrec [CreateCoreNetwork]
ReadPrec CreateCoreNetwork
Int -> ReadS CreateCoreNetwork
ReadS [CreateCoreNetwork]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCoreNetwork]
$creadListPrec :: ReadPrec [CreateCoreNetwork]
readPrec :: ReadPrec CreateCoreNetwork
$creadPrec :: ReadPrec CreateCoreNetwork
readList :: ReadS [CreateCoreNetwork]
$creadList :: ReadS [CreateCoreNetwork]
readsPrec :: Int -> ReadS CreateCoreNetwork
$creadsPrec :: Int -> ReadS CreateCoreNetwork
Prelude.Read, Int -> CreateCoreNetwork -> ShowS
[CreateCoreNetwork] -> ShowS
CreateCoreNetwork -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCoreNetwork] -> ShowS
$cshowList :: [CreateCoreNetwork] -> ShowS
show :: CreateCoreNetwork -> String
$cshow :: CreateCoreNetwork -> String
showsPrec :: Int -> CreateCoreNetwork -> ShowS
$cshowsPrec :: Int -> CreateCoreNetwork -> ShowS
Prelude.Show, forall x. Rep CreateCoreNetwork x -> CreateCoreNetwork
forall x. CreateCoreNetwork -> Rep CreateCoreNetwork x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateCoreNetwork x -> CreateCoreNetwork
$cfrom :: forall x. CreateCoreNetwork -> Rep CreateCoreNetwork x
Prelude.Generic)

-- |
-- Create a value of 'CreateCoreNetwork' 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:
--
-- 'clientToken', 'createCoreNetwork_clientToken' - The client token associated with a core network request.
--
-- 'description', 'createCoreNetwork_description' - The description of a core network.
--
-- 'policyDocument', 'createCoreNetwork_policyDocument' - The policy document for creating a core network.
--
-- 'tags', 'createCoreNetwork_tags' - Key-value tags associated with a core network request.
--
-- 'globalNetworkId', 'createCoreNetwork_globalNetworkId' - The ID of the global network that a core network will be a part of.
newCreateCoreNetwork ::
  -- | 'globalNetworkId'
  Prelude.Text ->
  CreateCoreNetwork
newCreateCoreNetwork :: Text -> CreateCoreNetwork
newCreateCoreNetwork Text
pGlobalNetworkId_ =
  CreateCoreNetwork'
    { $sel:clientToken:CreateCoreNetwork' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateCoreNetwork' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:policyDocument:CreateCoreNetwork' :: Maybe Text
policyDocument = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateCoreNetwork' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:globalNetworkId:CreateCoreNetwork' :: Text
globalNetworkId = Text
pGlobalNetworkId_
    }

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

-- | The description of a core network.
createCoreNetwork_description :: Lens.Lens' CreateCoreNetwork (Prelude.Maybe Prelude.Text)
createCoreNetwork_description :: Lens' CreateCoreNetwork (Maybe Text)
createCoreNetwork_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCoreNetwork' {Maybe Text
description :: Maybe Text
$sel:description:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateCoreNetwork
s@CreateCoreNetwork' {} Maybe Text
a -> CreateCoreNetwork
s {$sel:description:CreateCoreNetwork' :: Maybe Text
description = Maybe Text
a} :: CreateCoreNetwork)

-- | The policy document for creating a core network.
createCoreNetwork_policyDocument :: Lens.Lens' CreateCoreNetwork (Prelude.Maybe Prelude.Text)
createCoreNetwork_policyDocument :: Lens' CreateCoreNetwork (Maybe Text)
createCoreNetwork_policyDocument = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCoreNetwork' {Maybe Text
policyDocument :: Maybe Text
$sel:policyDocument:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
policyDocument} -> Maybe Text
policyDocument) (\s :: CreateCoreNetwork
s@CreateCoreNetwork' {} Maybe Text
a -> CreateCoreNetwork
s {$sel:policyDocument:CreateCoreNetwork' :: Maybe Text
policyDocument = Maybe Text
a} :: CreateCoreNetwork)

-- | Key-value tags associated with a core network request.
createCoreNetwork_tags :: Lens.Lens' CreateCoreNetwork (Prelude.Maybe [Tag])
createCoreNetwork_tags :: Lens' CreateCoreNetwork (Maybe [Tag])
createCoreNetwork_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCoreNetwork' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateCoreNetwork
s@CreateCoreNetwork' {} Maybe [Tag]
a -> CreateCoreNetwork
s {$sel:tags:CreateCoreNetwork' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateCoreNetwork) 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 global network that a core network will be a part of.
createCoreNetwork_globalNetworkId :: Lens.Lens' CreateCoreNetwork Prelude.Text
createCoreNetwork_globalNetworkId :: Lens' CreateCoreNetwork Text
createCoreNetwork_globalNetworkId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCoreNetwork' {Text
globalNetworkId :: Text
$sel:globalNetworkId:CreateCoreNetwork' :: CreateCoreNetwork -> Text
globalNetworkId} -> Text
globalNetworkId) (\s :: CreateCoreNetwork
s@CreateCoreNetwork' {} Text
a -> CreateCoreNetwork
s {$sel:globalNetworkId:CreateCoreNetwork' :: Text
globalNetworkId = Text
a} :: CreateCoreNetwork)

instance Core.AWSRequest CreateCoreNetwork where
  type
    AWSResponse CreateCoreNetwork =
      CreateCoreNetworkResponse
  request :: (Service -> Service)
-> CreateCoreNetwork -> Request CreateCoreNetwork
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 CreateCoreNetwork
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateCoreNetwork)))
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 CoreNetwork -> Int -> CreateCoreNetworkResponse
CreateCoreNetworkResponse'
            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
"CoreNetwork")
            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 CreateCoreNetwork where
  hashWithSalt :: Int -> CreateCoreNetwork -> Int
hashWithSalt Int
_salt CreateCoreNetwork' {Maybe [Tag]
Maybe Text
Text
globalNetworkId :: Text
tags :: Maybe [Tag]
policyDocument :: Maybe Text
description :: Maybe Text
clientToken :: Maybe Text
$sel:globalNetworkId:CreateCoreNetwork' :: CreateCoreNetwork -> Text
$sel:tags:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe [Tag]
$sel:policyDocument:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
$sel:description:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
$sel:clientToken:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
policyDocument
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
globalNetworkId

instance Prelude.NFData CreateCoreNetwork where
  rnf :: CreateCoreNetwork -> ()
rnf CreateCoreNetwork' {Maybe [Tag]
Maybe Text
Text
globalNetworkId :: Text
tags :: Maybe [Tag]
policyDocument :: Maybe Text
description :: Maybe Text
clientToken :: Maybe Text
$sel:globalNetworkId:CreateCoreNetwork' :: CreateCoreNetwork -> Text
$sel:tags:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe [Tag]
$sel:policyDocument:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
$sel:description:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
$sel:clientToken:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
..} =
    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
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
policyDocument
      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
globalNetworkId

instance Data.ToHeaders CreateCoreNetwork where
  toHeaders :: CreateCoreNetwork -> 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 CreateCoreNetwork where
  toJSON :: CreateCoreNetwork -> Value
toJSON CreateCoreNetwork' {Maybe [Tag]
Maybe Text
Text
globalNetworkId :: Text
tags :: Maybe [Tag]
policyDocument :: Maybe Text
description :: Maybe Text
clientToken :: Maybe Text
$sel:globalNetworkId:CreateCoreNetwork' :: CreateCoreNetwork -> Text
$sel:tags:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe [Tag]
$sel:policyDocument:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
$sel:description:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
$sel:clientToken:CreateCoreNetwork' :: CreateCoreNetwork -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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
"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
"PolicyDocument" 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
policyDocument,
            (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
"GlobalNetworkId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
globalNetworkId)
          ]
      )

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

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

-- | /See:/ 'newCreateCoreNetworkResponse' smart constructor.
data CreateCoreNetworkResponse = CreateCoreNetworkResponse'
  { -- | Returns details about a core network.
    CreateCoreNetworkResponse -> Maybe CoreNetwork
coreNetwork :: Prelude.Maybe CoreNetwork,
    -- | The response's http status code.
    CreateCoreNetworkResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateCoreNetworkResponse -> CreateCoreNetworkResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateCoreNetworkResponse -> CreateCoreNetworkResponse -> Bool
$c/= :: CreateCoreNetworkResponse -> CreateCoreNetworkResponse -> Bool
== :: CreateCoreNetworkResponse -> CreateCoreNetworkResponse -> Bool
$c== :: CreateCoreNetworkResponse -> CreateCoreNetworkResponse -> Bool
Prelude.Eq, ReadPrec [CreateCoreNetworkResponse]
ReadPrec CreateCoreNetworkResponse
Int -> ReadS CreateCoreNetworkResponse
ReadS [CreateCoreNetworkResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateCoreNetworkResponse]
$creadListPrec :: ReadPrec [CreateCoreNetworkResponse]
readPrec :: ReadPrec CreateCoreNetworkResponse
$creadPrec :: ReadPrec CreateCoreNetworkResponse
readList :: ReadS [CreateCoreNetworkResponse]
$creadList :: ReadS [CreateCoreNetworkResponse]
readsPrec :: Int -> ReadS CreateCoreNetworkResponse
$creadsPrec :: Int -> ReadS CreateCoreNetworkResponse
Prelude.Read, Int -> CreateCoreNetworkResponse -> ShowS
[CreateCoreNetworkResponse] -> ShowS
CreateCoreNetworkResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateCoreNetworkResponse] -> ShowS
$cshowList :: [CreateCoreNetworkResponse] -> ShowS
show :: CreateCoreNetworkResponse -> String
$cshow :: CreateCoreNetworkResponse -> String
showsPrec :: Int -> CreateCoreNetworkResponse -> ShowS
$cshowsPrec :: Int -> CreateCoreNetworkResponse -> ShowS
Prelude.Show, forall x.
Rep CreateCoreNetworkResponse x -> CreateCoreNetworkResponse
forall x.
CreateCoreNetworkResponse -> Rep CreateCoreNetworkResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateCoreNetworkResponse x -> CreateCoreNetworkResponse
$cfrom :: forall x.
CreateCoreNetworkResponse -> Rep CreateCoreNetworkResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateCoreNetworkResponse' 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:
--
-- 'coreNetwork', 'createCoreNetworkResponse_coreNetwork' - Returns details about a core network.
--
-- 'httpStatus', 'createCoreNetworkResponse_httpStatus' - The response's http status code.
newCreateCoreNetworkResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateCoreNetworkResponse
newCreateCoreNetworkResponse :: Int -> CreateCoreNetworkResponse
newCreateCoreNetworkResponse Int
pHttpStatus_ =
  CreateCoreNetworkResponse'
    { $sel:coreNetwork:CreateCoreNetworkResponse' :: Maybe CoreNetwork
coreNetwork =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateCoreNetworkResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Returns details about a core network.
createCoreNetworkResponse_coreNetwork :: Lens.Lens' CreateCoreNetworkResponse (Prelude.Maybe CoreNetwork)
createCoreNetworkResponse_coreNetwork :: Lens' CreateCoreNetworkResponse (Maybe CoreNetwork)
createCoreNetworkResponse_coreNetwork = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateCoreNetworkResponse' {Maybe CoreNetwork
coreNetwork :: Maybe CoreNetwork
$sel:coreNetwork:CreateCoreNetworkResponse' :: CreateCoreNetworkResponse -> Maybe CoreNetwork
coreNetwork} -> Maybe CoreNetwork
coreNetwork) (\s :: CreateCoreNetworkResponse
s@CreateCoreNetworkResponse' {} Maybe CoreNetwork
a -> CreateCoreNetworkResponse
s {$sel:coreNetwork:CreateCoreNetworkResponse' :: Maybe CoreNetwork
coreNetwork = Maybe CoreNetwork
a} :: CreateCoreNetworkResponse)

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

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