{-# 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.Lambda.PublishLayerVersion
-- 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 an
-- <https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html Lambda layer>
-- from a ZIP archive. Each time you call @PublishLayerVersion@ with the
-- same layer name, a new version is created.
--
-- Add layers to your function with CreateFunction or
-- UpdateFunctionConfiguration.
module Amazonka.Lambda.PublishLayerVersion
  ( -- * Creating a Request
    PublishLayerVersion (..),
    newPublishLayerVersion,

    -- * Request Lenses
    publishLayerVersion_compatibleArchitectures,
    publishLayerVersion_compatibleRuntimes,
    publishLayerVersion_description,
    publishLayerVersion_licenseInfo,
    publishLayerVersion_layerName,
    publishLayerVersion_content,

    -- * Destructuring the Response
    PublishLayerVersionResponse (..),
    newPublishLayerVersionResponse,

    -- * Response Lenses
    publishLayerVersionResponse_compatibleArchitectures,
    publishLayerVersionResponse_compatibleRuntimes,
    publishLayerVersionResponse_content,
    publishLayerVersionResponse_createdDate,
    publishLayerVersionResponse_description,
    publishLayerVersionResponse_layerArn,
    publishLayerVersionResponse_layerVersionArn,
    publishLayerVersionResponse_licenseInfo,
    publishLayerVersionResponse_version,
    publishLayerVersionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newPublishLayerVersion' smart constructor.
data PublishLayerVersion = PublishLayerVersion'
  { -- | A list of compatible
    -- <https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html instruction set architectures>.
    PublishLayerVersion -> Maybe [Architecture]
compatibleArchitectures :: Prelude.Maybe [Architecture],
    -- | A list of compatible
    -- <https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html function runtimes>.
    -- Used for filtering with ListLayers and ListLayerVersions.
    PublishLayerVersion -> Maybe [Runtime]
compatibleRuntimes :: Prelude.Maybe [Runtime],
    -- | The description of the version.
    PublishLayerVersion -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The layer\'s software license. It can be any of the following:
    --
    -- -   An <https://spdx.org/licenses/ SPDX license identifier>. For
    --     example, @MIT@.
    --
    -- -   The URL of a license hosted on the internet. For example,
    --     @https:\/\/opensource.org\/licenses\/MIT@.
    --
    -- -   The full text of the license.
    PublishLayerVersion -> Maybe Text
licenseInfo :: Prelude.Maybe Prelude.Text,
    -- | The name or Amazon Resource Name (ARN) of the layer.
    PublishLayerVersion -> Text
layerName :: Prelude.Text,
    -- | The function layer archive.
    PublishLayerVersion -> LayerVersionContentInput
content :: LayerVersionContentInput
  }
  deriving (PublishLayerVersion -> PublishLayerVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PublishLayerVersion -> PublishLayerVersion -> Bool
$c/= :: PublishLayerVersion -> PublishLayerVersion -> Bool
== :: PublishLayerVersion -> PublishLayerVersion -> Bool
$c== :: PublishLayerVersion -> PublishLayerVersion -> Bool
Prelude.Eq, Int -> PublishLayerVersion -> ShowS
[PublishLayerVersion] -> ShowS
PublishLayerVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PublishLayerVersion] -> ShowS
$cshowList :: [PublishLayerVersion] -> ShowS
show :: PublishLayerVersion -> String
$cshow :: PublishLayerVersion -> String
showsPrec :: Int -> PublishLayerVersion -> ShowS
$cshowsPrec :: Int -> PublishLayerVersion -> ShowS
Prelude.Show, forall x. Rep PublishLayerVersion x -> PublishLayerVersion
forall x. PublishLayerVersion -> Rep PublishLayerVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PublishLayerVersion x -> PublishLayerVersion
$cfrom :: forall x. PublishLayerVersion -> Rep PublishLayerVersion x
Prelude.Generic)

-- |
-- Create a value of 'PublishLayerVersion' 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:
--
-- 'compatibleArchitectures', 'publishLayerVersion_compatibleArchitectures' - A list of compatible
-- <https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html instruction set architectures>.
--
-- 'compatibleRuntimes', 'publishLayerVersion_compatibleRuntimes' - A list of compatible
-- <https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html function runtimes>.
-- Used for filtering with ListLayers and ListLayerVersions.
--
-- 'description', 'publishLayerVersion_description' - The description of the version.
--
-- 'licenseInfo', 'publishLayerVersion_licenseInfo' - The layer\'s software license. It can be any of the following:
--
-- -   An <https://spdx.org/licenses/ SPDX license identifier>. For
--     example, @MIT@.
--
-- -   The URL of a license hosted on the internet. For example,
--     @https:\/\/opensource.org\/licenses\/MIT@.
--
-- -   The full text of the license.
--
-- 'layerName', 'publishLayerVersion_layerName' - The name or Amazon Resource Name (ARN) of the layer.
--
-- 'content', 'publishLayerVersion_content' - The function layer archive.
newPublishLayerVersion ::
  -- | 'layerName'
  Prelude.Text ->
  -- | 'content'
  LayerVersionContentInput ->
  PublishLayerVersion
newPublishLayerVersion :: Text -> LayerVersionContentInput -> PublishLayerVersion
newPublishLayerVersion Text
pLayerName_ LayerVersionContentInput
pContent_ =
  PublishLayerVersion'
    { $sel:compatibleArchitectures:PublishLayerVersion' :: Maybe [Architecture]
compatibleArchitectures =
        forall a. Maybe a
Prelude.Nothing,
      $sel:compatibleRuntimes:PublishLayerVersion' :: Maybe [Runtime]
compatibleRuntimes = forall a. Maybe a
Prelude.Nothing,
      $sel:description:PublishLayerVersion' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:licenseInfo:PublishLayerVersion' :: Maybe Text
licenseInfo = forall a. Maybe a
Prelude.Nothing,
      $sel:layerName:PublishLayerVersion' :: Text
layerName = Text
pLayerName_,
      $sel:content:PublishLayerVersion' :: LayerVersionContentInput
content = LayerVersionContentInput
pContent_
    }

-- | A list of compatible
-- <https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html instruction set architectures>.
publishLayerVersion_compatibleArchitectures :: Lens.Lens' PublishLayerVersion (Prelude.Maybe [Architecture])
publishLayerVersion_compatibleArchitectures :: Lens' PublishLayerVersion (Maybe [Architecture])
publishLayerVersion_compatibleArchitectures = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersion' {Maybe [Architecture]
compatibleArchitectures :: Maybe [Architecture]
$sel:compatibleArchitectures:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Architecture]
compatibleArchitectures} -> Maybe [Architecture]
compatibleArchitectures) (\s :: PublishLayerVersion
s@PublishLayerVersion' {} Maybe [Architecture]
a -> PublishLayerVersion
s {$sel:compatibleArchitectures:PublishLayerVersion' :: Maybe [Architecture]
compatibleArchitectures = Maybe [Architecture]
a} :: PublishLayerVersion) 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

-- | A list of compatible
-- <https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html function runtimes>.
-- Used for filtering with ListLayers and ListLayerVersions.
publishLayerVersion_compatibleRuntimes :: Lens.Lens' PublishLayerVersion (Prelude.Maybe [Runtime])
publishLayerVersion_compatibleRuntimes :: Lens' PublishLayerVersion (Maybe [Runtime])
publishLayerVersion_compatibleRuntimes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersion' {Maybe [Runtime]
compatibleRuntimes :: Maybe [Runtime]
$sel:compatibleRuntimes:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Runtime]
compatibleRuntimes} -> Maybe [Runtime]
compatibleRuntimes) (\s :: PublishLayerVersion
s@PublishLayerVersion' {} Maybe [Runtime]
a -> PublishLayerVersion
s {$sel:compatibleRuntimes:PublishLayerVersion' :: Maybe [Runtime]
compatibleRuntimes = Maybe [Runtime]
a} :: PublishLayerVersion) 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 description of the version.
publishLayerVersion_description :: Lens.Lens' PublishLayerVersion (Prelude.Maybe Prelude.Text)
publishLayerVersion_description :: Lens' PublishLayerVersion (Maybe Text)
publishLayerVersion_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersion' {Maybe Text
description :: Maybe Text
$sel:description:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
description} -> Maybe Text
description) (\s :: PublishLayerVersion
s@PublishLayerVersion' {} Maybe Text
a -> PublishLayerVersion
s {$sel:description:PublishLayerVersion' :: Maybe Text
description = Maybe Text
a} :: PublishLayerVersion)

-- | The layer\'s software license. It can be any of the following:
--
-- -   An <https://spdx.org/licenses/ SPDX license identifier>. For
--     example, @MIT@.
--
-- -   The URL of a license hosted on the internet. For example,
--     @https:\/\/opensource.org\/licenses\/MIT@.
--
-- -   The full text of the license.
publishLayerVersion_licenseInfo :: Lens.Lens' PublishLayerVersion (Prelude.Maybe Prelude.Text)
publishLayerVersion_licenseInfo :: Lens' PublishLayerVersion (Maybe Text)
publishLayerVersion_licenseInfo = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersion' {Maybe Text
licenseInfo :: Maybe Text
$sel:licenseInfo:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
licenseInfo} -> Maybe Text
licenseInfo) (\s :: PublishLayerVersion
s@PublishLayerVersion' {} Maybe Text
a -> PublishLayerVersion
s {$sel:licenseInfo:PublishLayerVersion' :: Maybe Text
licenseInfo = Maybe Text
a} :: PublishLayerVersion)

-- | The name or Amazon Resource Name (ARN) of the layer.
publishLayerVersion_layerName :: Lens.Lens' PublishLayerVersion Prelude.Text
publishLayerVersion_layerName :: Lens' PublishLayerVersion Text
publishLayerVersion_layerName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersion' {Text
layerName :: Text
$sel:layerName:PublishLayerVersion' :: PublishLayerVersion -> Text
layerName} -> Text
layerName) (\s :: PublishLayerVersion
s@PublishLayerVersion' {} Text
a -> PublishLayerVersion
s {$sel:layerName:PublishLayerVersion' :: Text
layerName = Text
a} :: PublishLayerVersion)

-- | The function layer archive.
publishLayerVersion_content :: Lens.Lens' PublishLayerVersion LayerVersionContentInput
publishLayerVersion_content :: Lens' PublishLayerVersion LayerVersionContentInput
publishLayerVersion_content = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersion' {LayerVersionContentInput
content :: LayerVersionContentInput
$sel:content:PublishLayerVersion' :: PublishLayerVersion -> LayerVersionContentInput
content} -> LayerVersionContentInput
content) (\s :: PublishLayerVersion
s@PublishLayerVersion' {} LayerVersionContentInput
a -> PublishLayerVersion
s {$sel:content:PublishLayerVersion' :: LayerVersionContentInput
content = LayerVersionContentInput
a} :: PublishLayerVersion)

instance Core.AWSRequest PublishLayerVersion where
  type
    AWSResponse PublishLayerVersion =
      PublishLayerVersionResponse
  request :: (Service -> Service)
-> PublishLayerVersion -> Request PublishLayerVersion
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 PublishLayerVersion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse PublishLayerVersion)))
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 [Architecture]
-> Maybe [Runtime]
-> Maybe LayerVersionContentOutput
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Integer
-> Int
-> PublishLayerVersionResponse
PublishLayerVersionResponse'
            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
"CompatibleArchitectures"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            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
"CompatibleRuntimes"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            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
"Content")
            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
"CreatedDate")
            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
"Description")
            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
"LayerArn")
            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
"LayerVersionArn")
            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
"LicenseInfo")
            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
"Version")
            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 PublishLayerVersion where
  hashWithSalt :: Int -> PublishLayerVersion -> Int
hashWithSalt Int
_salt PublishLayerVersion' {Maybe [Architecture]
Maybe [Runtime]
Maybe Text
Text
LayerVersionContentInput
content :: LayerVersionContentInput
layerName :: Text
licenseInfo :: Maybe Text
description :: Maybe Text
compatibleRuntimes :: Maybe [Runtime]
compatibleArchitectures :: Maybe [Architecture]
$sel:content:PublishLayerVersion' :: PublishLayerVersion -> LayerVersionContentInput
$sel:layerName:PublishLayerVersion' :: PublishLayerVersion -> Text
$sel:licenseInfo:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:description:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:compatibleRuntimes:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Runtime]
$sel:compatibleArchitectures:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Architecture]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Architecture]
compatibleArchitectures
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Runtime]
compatibleRuntimes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
licenseInfo
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
layerName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` LayerVersionContentInput
content

instance Prelude.NFData PublishLayerVersion where
  rnf :: PublishLayerVersion -> ()
rnf PublishLayerVersion' {Maybe [Architecture]
Maybe [Runtime]
Maybe Text
Text
LayerVersionContentInput
content :: LayerVersionContentInput
layerName :: Text
licenseInfo :: Maybe Text
description :: Maybe Text
compatibleRuntimes :: Maybe [Runtime]
compatibleArchitectures :: Maybe [Architecture]
$sel:content:PublishLayerVersion' :: PublishLayerVersion -> LayerVersionContentInput
$sel:layerName:PublishLayerVersion' :: PublishLayerVersion -> Text
$sel:licenseInfo:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:description:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:compatibleRuntimes:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Runtime]
$sel:compatibleArchitectures:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Architecture]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Architecture]
compatibleArchitectures
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Runtime]
compatibleRuntimes
      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
licenseInfo
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
layerName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf LayerVersionContentInput
content

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

instance Data.ToJSON PublishLayerVersion where
  toJSON :: PublishLayerVersion -> Value
toJSON PublishLayerVersion' {Maybe [Architecture]
Maybe [Runtime]
Maybe Text
Text
LayerVersionContentInput
content :: LayerVersionContentInput
layerName :: Text
licenseInfo :: Maybe Text
description :: Maybe Text
compatibleRuntimes :: Maybe [Runtime]
compatibleArchitectures :: Maybe [Architecture]
$sel:content:PublishLayerVersion' :: PublishLayerVersion -> LayerVersionContentInput
$sel:layerName:PublishLayerVersion' :: PublishLayerVersion -> Text
$sel:licenseInfo:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:description:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:compatibleRuntimes:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Runtime]
$sel:compatibleArchitectures:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Architecture]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CompatibleArchitectures" 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 [Architecture]
compatibleArchitectures,
            (Key
"CompatibleRuntimes" 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 [Runtime]
compatibleRuntimes,
            (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
"LicenseInfo" 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
licenseInfo,
            forall a. a -> Maybe a
Prelude.Just (Key
"Content" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= LayerVersionContentInput
content)
          ]
      )

instance Data.ToPath PublishLayerVersion where
  toPath :: PublishLayerVersion -> ByteString
toPath PublishLayerVersion' {Maybe [Architecture]
Maybe [Runtime]
Maybe Text
Text
LayerVersionContentInput
content :: LayerVersionContentInput
layerName :: Text
licenseInfo :: Maybe Text
description :: Maybe Text
compatibleRuntimes :: Maybe [Runtime]
compatibleArchitectures :: Maybe [Architecture]
$sel:content:PublishLayerVersion' :: PublishLayerVersion -> LayerVersionContentInput
$sel:layerName:PublishLayerVersion' :: PublishLayerVersion -> Text
$sel:licenseInfo:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:description:PublishLayerVersion' :: PublishLayerVersion -> Maybe Text
$sel:compatibleRuntimes:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Runtime]
$sel:compatibleArchitectures:PublishLayerVersion' :: PublishLayerVersion -> Maybe [Architecture]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/2018-10-31/layers/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
layerName,
        ByteString
"/versions"
      ]

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

-- | /See:/ 'newPublishLayerVersionResponse' smart constructor.
data PublishLayerVersionResponse = PublishLayerVersionResponse'
  { -- | A list of compatible
    -- <https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html instruction set architectures>.
    PublishLayerVersionResponse -> Maybe [Architecture]
compatibleArchitectures :: Prelude.Maybe [Architecture],
    -- | The layer\'s compatible runtimes.
    PublishLayerVersionResponse -> Maybe [Runtime]
compatibleRuntimes :: Prelude.Maybe [Runtime],
    -- | Details about the layer version.
    PublishLayerVersionResponse -> Maybe LayerVersionContentOutput
content :: Prelude.Maybe LayerVersionContentOutput,
    -- | The date that the layer version was created, in
    -- <https://www.w3.org/TR/NOTE-datetime ISO-8601 format>
    -- (YYYY-MM-DDThh:mm:ss.sTZD).
    PublishLayerVersionResponse -> Maybe Text
createdDate :: Prelude.Maybe Prelude.Text,
    -- | The description of the version.
    PublishLayerVersionResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the layer.
    PublishLayerVersionResponse -> Maybe Text
layerArn :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the layer version.
    PublishLayerVersionResponse -> Maybe Text
layerVersionArn :: Prelude.Maybe Prelude.Text,
    -- | The layer\'s software license.
    PublishLayerVersionResponse -> Maybe Text
licenseInfo :: Prelude.Maybe Prelude.Text,
    -- | The version number.
    PublishLayerVersionResponse -> Maybe Integer
version :: Prelude.Maybe Prelude.Integer,
    -- | The response's http status code.
    PublishLayerVersionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (PublishLayerVersionResponse -> PublishLayerVersionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PublishLayerVersionResponse -> PublishLayerVersionResponse -> Bool
$c/= :: PublishLayerVersionResponse -> PublishLayerVersionResponse -> Bool
== :: PublishLayerVersionResponse -> PublishLayerVersionResponse -> Bool
$c== :: PublishLayerVersionResponse -> PublishLayerVersionResponse -> Bool
Prelude.Eq, ReadPrec [PublishLayerVersionResponse]
ReadPrec PublishLayerVersionResponse
Int -> ReadS PublishLayerVersionResponse
ReadS [PublishLayerVersionResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PublishLayerVersionResponse]
$creadListPrec :: ReadPrec [PublishLayerVersionResponse]
readPrec :: ReadPrec PublishLayerVersionResponse
$creadPrec :: ReadPrec PublishLayerVersionResponse
readList :: ReadS [PublishLayerVersionResponse]
$creadList :: ReadS [PublishLayerVersionResponse]
readsPrec :: Int -> ReadS PublishLayerVersionResponse
$creadsPrec :: Int -> ReadS PublishLayerVersionResponse
Prelude.Read, Int -> PublishLayerVersionResponse -> ShowS
[PublishLayerVersionResponse] -> ShowS
PublishLayerVersionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PublishLayerVersionResponse] -> ShowS
$cshowList :: [PublishLayerVersionResponse] -> ShowS
show :: PublishLayerVersionResponse -> String
$cshow :: PublishLayerVersionResponse -> String
showsPrec :: Int -> PublishLayerVersionResponse -> ShowS
$cshowsPrec :: Int -> PublishLayerVersionResponse -> ShowS
Prelude.Show, forall x.
Rep PublishLayerVersionResponse x -> PublishLayerVersionResponse
forall x.
PublishLayerVersionResponse -> Rep PublishLayerVersionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep PublishLayerVersionResponse x -> PublishLayerVersionResponse
$cfrom :: forall x.
PublishLayerVersionResponse -> Rep PublishLayerVersionResponse x
Prelude.Generic)

-- |
-- Create a value of 'PublishLayerVersionResponse' 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:
--
-- 'compatibleArchitectures', 'publishLayerVersionResponse_compatibleArchitectures' - A list of compatible
-- <https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html instruction set architectures>.
--
-- 'compatibleRuntimes', 'publishLayerVersionResponse_compatibleRuntimes' - The layer\'s compatible runtimes.
--
-- 'content', 'publishLayerVersionResponse_content' - Details about the layer version.
--
-- 'createdDate', 'publishLayerVersionResponse_createdDate' - The date that the layer version was created, in
-- <https://www.w3.org/TR/NOTE-datetime ISO-8601 format>
-- (YYYY-MM-DDThh:mm:ss.sTZD).
--
-- 'description', 'publishLayerVersionResponse_description' - The description of the version.
--
-- 'layerArn', 'publishLayerVersionResponse_layerArn' - The ARN of the layer.
--
-- 'layerVersionArn', 'publishLayerVersionResponse_layerVersionArn' - The ARN of the layer version.
--
-- 'licenseInfo', 'publishLayerVersionResponse_licenseInfo' - The layer\'s software license.
--
-- 'version', 'publishLayerVersionResponse_version' - The version number.
--
-- 'httpStatus', 'publishLayerVersionResponse_httpStatus' - The response's http status code.
newPublishLayerVersionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PublishLayerVersionResponse
newPublishLayerVersionResponse :: Int -> PublishLayerVersionResponse
newPublishLayerVersionResponse Int
pHttpStatus_ =
  PublishLayerVersionResponse'
    { $sel:compatibleArchitectures:PublishLayerVersionResponse' :: Maybe [Architecture]
compatibleArchitectures =
        forall a. Maybe a
Prelude.Nothing,
      $sel:compatibleRuntimes:PublishLayerVersionResponse' :: Maybe [Runtime]
compatibleRuntimes = forall a. Maybe a
Prelude.Nothing,
      $sel:content:PublishLayerVersionResponse' :: Maybe LayerVersionContentOutput
content = forall a. Maybe a
Prelude.Nothing,
      $sel:createdDate:PublishLayerVersionResponse' :: Maybe Text
createdDate = forall a. Maybe a
Prelude.Nothing,
      $sel:description:PublishLayerVersionResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:layerArn:PublishLayerVersionResponse' :: Maybe Text
layerArn = forall a. Maybe a
Prelude.Nothing,
      $sel:layerVersionArn:PublishLayerVersionResponse' :: Maybe Text
layerVersionArn = forall a. Maybe a
Prelude.Nothing,
      $sel:licenseInfo:PublishLayerVersionResponse' :: Maybe Text
licenseInfo = forall a. Maybe a
Prelude.Nothing,
      $sel:version:PublishLayerVersionResponse' :: Maybe Integer
version = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:PublishLayerVersionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of compatible
-- <https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html instruction set architectures>.
publishLayerVersionResponse_compatibleArchitectures :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe [Architecture])
publishLayerVersionResponse_compatibleArchitectures :: Lens' PublishLayerVersionResponse (Maybe [Architecture])
publishLayerVersionResponse_compatibleArchitectures = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe [Architecture]
compatibleArchitectures :: Maybe [Architecture]
$sel:compatibleArchitectures:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe [Architecture]
compatibleArchitectures} -> Maybe [Architecture]
compatibleArchitectures) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe [Architecture]
a -> PublishLayerVersionResponse
s {$sel:compatibleArchitectures:PublishLayerVersionResponse' :: Maybe [Architecture]
compatibleArchitectures = Maybe [Architecture]
a} :: PublishLayerVersionResponse) 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 layer\'s compatible runtimes.
publishLayerVersionResponse_compatibleRuntimes :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe [Runtime])
publishLayerVersionResponse_compatibleRuntimes :: Lens' PublishLayerVersionResponse (Maybe [Runtime])
publishLayerVersionResponse_compatibleRuntimes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe [Runtime]
compatibleRuntimes :: Maybe [Runtime]
$sel:compatibleRuntimes:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe [Runtime]
compatibleRuntimes} -> Maybe [Runtime]
compatibleRuntimes) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe [Runtime]
a -> PublishLayerVersionResponse
s {$sel:compatibleRuntimes:PublishLayerVersionResponse' :: Maybe [Runtime]
compatibleRuntimes = Maybe [Runtime]
a} :: PublishLayerVersionResponse) 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

-- | Details about the layer version.
publishLayerVersionResponse_content :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe LayerVersionContentOutput)
publishLayerVersionResponse_content :: Lens' PublishLayerVersionResponse (Maybe LayerVersionContentOutput)
publishLayerVersionResponse_content = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe LayerVersionContentOutput
content :: Maybe LayerVersionContentOutput
$sel:content:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe LayerVersionContentOutput
content} -> Maybe LayerVersionContentOutput
content) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe LayerVersionContentOutput
a -> PublishLayerVersionResponse
s {$sel:content:PublishLayerVersionResponse' :: Maybe LayerVersionContentOutput
content = Maybe LayerVersionContentOutput
a} :: PublishLayerVersionResponse)

-- | The date that the layer version was created, in
-- <https://www.w3.org/TR/NOTE-datetime ISO-8601 format>
-- (YYYY-MM-DDThh:mm:ss.sTZD).
publishLayerVersionResponse_createdDate :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe Prelude.Text)
publishLayerVersionResponse_createdDate :: Lens' PublishLayerVersionResponse (Maybe Text)
publishLayerVersionResponse_createdDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe Text
createdDate :: Maybe Text
$sel:createdDate:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
createdDate} -> Maybe Text
createdDate) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe Text
a -> PublishLayerVersionResponse
s {$sel:createdDate:PublishLayerVersionResponse' :: Maybe Text
createdDate = Maybe Text
a} :: PublishLayerVersionResponse)

-- | The description of the version.
publishLayerVersionResponse_description :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe Prelude.Text)
publishLayerVersionResponse_description :: Lens' PublishLayerVersionResponse (Maybe Text)
publishLayerVersionResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe Text
description :: Maybe Text
$sel:description:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe Text
a -> PublishLayerVersionResponse
s {$sel:description:PublishLayerVersionResponse' :: Maybe Text
description = Maybe Text
a} :: PublishLayerVersionResponse)

-- | The ARN of the layer.
publishLayerVersionResponse_layerArn :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe Prelude.Text)
publishLayerVersionResponse_layerArn :: Lens' PublishLayerVersionResponse (Maybe Text)
publishLayerVersionResponse_layerArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe Text
layerArn :: Maybe Text
$sel:layerArn:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
layerArn} -> Maybe Text
layerArn) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe Text
a -> PublishLayerVersionResponse
s {$sel:layerArn:PublishLayerVersionResponse' :: Maybe Text
layerArn = Maybe Text
a} :: PublishLayerVersionResponse)

-- | The ARN of the layer version.
publishLayerVersionResponse_layerVersionArn :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe Prelude.Text)
publishLayerVersionResponse_layerVersionArn :: Lens' PublishLayerVersionResponse (Maybe Text)
publishLayerVersionResponse_layerVersionArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe Text
layerVersionArn :: Maybe Text
$sel:layerVersionArn:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
layerVersionArn} -> Maybe Text
layerVersionArn) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe Text
a -> PublishLayerVersionResponse
s {$sel:layerVersionArn:PublishLayerVersionResponse' :: Maybe Text
layerVersionArn = Maybe Text
a} :: PublishLayerVersionResponse)

-- | The layer\'s software license.
publishLayerVersionResponse_licenseInfo :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe Prelude.Text)
publishLayerVersionResponse_licenseInfo :: Lens' PublishLayerVersionResponse (Maybe Text)
publishLayerVersionResponse_licenseInfo = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe Text
licenseInfo :: Maybe Text
$sel:licenseInfo:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
licenseInfo} -> Maybe Text
licenseInfo) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe Text
a -> PublishLayerVersionResponse
s {$sel:licenseInfo:PublishLayerVersionResponse' :: Maybe Text
licenseInfo = Maybe Text
a} :: PublishLayerVersionResponse)

-- | The version number.
publishLayerVersionResponse_version :: Lens.Lens' PublishLayerVersionResponse (Prelude.Maybe Prelude.Integer)
publishLayerVersionResponse_version :: Lens' PublishLayerVersionResponse (Maybe Integer)
publishLayerVersionResponse_version = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PublishLayerVersionResponse' {Maybe Integer
version :: Maybe Integer
$sel:version:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Integer
version} -> Maybe Integer
version) (\s :: PublishLayerVersionResponse
s@PublishLayerVersionResponse' {} Maybe Integer
a -> PublishLayerVersionResponse
s {$sel:version:PublishLayerVersionResponse' :: Maybe Integer
version = Maybe Integer
a} :: PublishLayerVersionResponse)

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

instance Prelude.NFData PublishLayerVersionResponse where
  rnf :: PublishLayerVersionResponse -> ()
rnf PublishLayerVersionResponse' {Int
Maybe Integer
Maybe [Architecture]
Maybe [Runtime]
Maybe Text
Maybe LayerVersionContentOutput
httpStatus :: Int
version :: Maybe Integer
licenseInfo :: Maybe Text
layerVersionArn :: Maybe Text
layerArn :: Maybe Text
description :: Maybe Text
createdDate :: Maybe Text
content :: Maybe LayerVersionContentOutput
compatibleRuntimes :: Maybe [Runtime]
compatibleArchitectures :: Maybe [Architecture]
$sel:httpStatus:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Int
$sel:version:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Integer
$sel:licenseInfo:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
$sel:layerVersionArn:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
$sel:layerArn:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
$sel:description:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
$sel:createdDate:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe Text
$sel:content:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe LayerVersionContentOutput
$sel:compatibleRuntimes:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe [Runtime]
$sel:compatibleArchitectures:PublishLayerVersionResponse' :: PublishLayerVersionResponse -> Maybe [Architecture]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Architecture]
compatibleArchitectures
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Runtime]
compatibleRuntimes
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LayerVersionContentOutput
content
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
createdDate
      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
layerArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
layerVersionArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
licenseInfo
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Integer
version
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus