{-# 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.Panorama.RegisterPackageVersion
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Registers a package version.
module Amazonka.Panorama.RegisterPackageVersion
  ( -- * Creating a Request
    RegisterPackageVersion (..),
    newRegisterPackageVersion,

    -- * Request Lenses
    registerPackageVersion_markLatest,
    registerPackageVersion_ownerAccount,
    registerPackageVersion_packageId,
    registerPackageVersion_packageVersion,
    registerPackageVersion_patchVersion,

    -- * Destructuring the Response
    RegisterPackageVersionResponse (..),
    newRegisterPackageVersionResponse,

    -- * Response Lenses
    registerPackageVersionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newRegisterPackageVersion' smart constructor.
data RegisterPackageVersion = RegisterPackageVersion'
  { -- | Whether to mark the new version as the latest version.
    RegisterPackageVersion -> Maybe Bool
markLatest :: Prelude.Maybe Prelude.Bool,
    -- | An owner account.
    RegisterPackageVersion -> Maybe Text
ownerAccount :: Prelude.Maybe Prelude.Text,
    -- | A package ID.
    RegisterPackageVersion -> Text
packageId :: Prelude.Text,
    -- | A package version.
    RegisterPackageVersion -> Text
packageVersion :: Prelude.Text,
    -- | A patch version.
    RegisterPackageVersion -> Text
patchVersion :: Prelude.Text
  }
  deriving (RegisterPackageVersion -> RegisterPackageVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterPackageVersion -> RegisterPackageVersion -> Bool
$c/= :: RegisterPackageVersion -> RegisterPackageVersion -> Bool
== :: RegisterPackageVersion -> RegisterPackageVersion -> Bool
$c== :: RegisterPackageVersion -> RegisterPackageVersion -> Bool
Prelude.Eq, ReadPrec [RegisterPackageVersion]
ReadPrec RegisterPackageVersion
Int -> ReadS RegisterPackageVersion
ReadS [RegisterPackageVersion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterPackageVersion]
$creadListPrec :: ReadPrec [RegisterPackageVersion]
readPrec :: ReadPrec RegisterPackageVersion
$creadPrec :: ReadPrec RegisterPackageVersion
readList :: ReadS [RegisterPackageVersion]
$creadList :: ReadS [RegisterPackageVersion]
readsPrec :: Int -> ReadS RegisterPackageVersion
$creadsPrec :: Int -> ReadS RegisterPackageVersion
Prelude.Read, Int -> RegisterPackageVersion -> ShowS
[RegisterPackageVersion] -> ShowS
RegisterPackageVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterPackageVersion] -> ShowS
$cshowList :: [RegisterPackageVersion] -> ShowS
show :: RegisterPackageVersion -> String
$cshow :: RegisterPackageVersion -> String
showsPrec :: Int -> RegisterPackageVersion -> ShowS
$cshowsPrec :: Int -> RegisterPackageVersion -> ShowS
Prelude.Show, forall x. Rep RegisterPackageVersion x -> RegisterPackageVersion
forall x. RegisterPackageVersion -> Rep RegisterPackageVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegisterPackageVersion x -> RegisterPackageVersion
$cfrom :: forall x. RegisterPackageVersion -> Rep RegisterPackageVersion x
Prelude.Generic)

-- |
-- Create a value of 'RegisterPackageVersion' 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:
--
-- 'markLatest', 'registerPackageVersion_markLatest' - Whether to mark the new version as the latest version.
--
-- 'ownerAccount', 'registerPackageVersion_ownerAccount' - An owner account.
--
-- 'packageId', 'registerPackageVersion_packageId' - A package ID.
--
-- 'packageVersion', 'registerPackageVersion_packageVersion' - A package version.
--
-- 'patchVersion', 'registerPackageVersion_patchVersion' - A patch version.
newRegisterPackageVersion ::
  -- | 'packageId'
  Prelude.Text ->
  -- | 'packageVersion'
  Prelude.Text ->
  -- | 'patchVersion'
  Prelude.Text ->
  RegisterPackageVersion
newRegisterPackageVersion :: Text -> Text -> Text -> RegisterPackageVersion
newRegisterPackageVersion
  Text
pPackageId_
  Text
pPackageVersion_
  Text
pPatchVersion_ =
    RegisterPackageVersion'
      { $sel:markLatest:RegisterPackageVersion' :: Maybe Bool
markLatest =
          forall a. Maybe a
Prelude.Nothing,
        $sel:ownerAccount:RegisterPackageVersion' :: Maybe Text
ownerAccount = forall a. Maybe a
Prelude.Nothing,
        $sel:packageId:RegisterPackageVersion' :: Text
packageId = Text
pPackageId_,
        $sel:packageVersion:RegisterPackageVersion' :: Text
packageVersion = Text
pPackageVersion_,
        $sel:patchVersion:RegisterPackageVersion' :: Text
patchVersion = Text
pPatchVersion_
      }

-- | Whether to mark the new version as the latest version.
registerPackageVersion_markLatest :: Lens.Lens' RegisterPackageVersion (Prelude.Maybe Prelude.Bool)
registerPackageVersion_markLatest :: Lens' RegisterPackageVersion (Maybe Bool)
registerPackageVersion_markLatest = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterPackageVersion' {Maybe Bool
markLatest :: Maybe Bool
$sel:markLatest:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Bool
markLatest} -> Maybe Bool
markLatest) (\s :: RegisterPackageVersion
s@RegisterPackageVersion' {} Maybe Bool
a -> RegisterPackageVersion
s {$sel:markLatest:RegisterPackageVersion' :: Maybe Bool
markLatest = Maybe Bool
a} :: RegisterPackageVersion)

-- | An owner account.
registerPackageVersion_ownerAccount :: Lens.Lens' RegisterPackageVersion (Prelude.Maybe Prelude.Text)
registerPackageVersion_ownerAccount :: Lens' RegisterPackageVersion (Maybe Text)
registerPackageVersion_ownerAccount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterPackageVersion' {Maybe Text
ownerAccount :: Maybe Text
$sel:ownerAccount:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Text
ownerAccount} -> Maybe Text
ownerAccount) (\s :: RegisterPackageVersion
s@RegisterPackageVersion' {} Maybe Text
a -> RegisterPackageVersion
s {$sel:ownerAccount:RegisterPackageVersion' :: Maybe Text
ownerAccount = Maybe Text
a} :: RegisterPackageVersion)

-- | A package ID.
registerPackageVersion_packageId :: Lens.Lens' RegisterPackageVersion Prelude.Text
registerPackageVersion_packageId :: Lens' RegisterPackageVersion Text
registerPackageVersion_packageId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterPackageVersion' {Text
packageId :: Text
$sel:packageId:RegisterPackageVersion' :: RegisterPackageVersion -> Text
packageId} -> Text
packageId) (\s :: RegisterPackageVersion
s@RegisterPackageVersion' {} Text
a -> RegisterPackageVersion
s {$sel:packageId:RegisterPackageVersion' :: Text
packageId = Text
a} :: RegisterPackageVersion)

-- | A package version.
registerPackageVersion_packageVersion :: Lens.Lens' RegisterPackageVersion Prelude.Text
registerPackageVersion_packageVersion :: Lens' RegisterPackageVersion Text
registerPackageVersion_packageVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterPackageVersion' {Text
packageVersion :: Text
$sel:packageVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
packageVersion} -> Text
packageVersion) (\s :: RegisterPackageVersion
s@RegisterPackageVersion' {} Text
a -> RegisterPackageVersion
s {$sel:packageVersion:RegisterPackageVersion' :: Text
packageVersion = Text
a} :: RegisterPackageVersion)

-- | A patch version.
registerPackageVersion_patchVersion :: Lens.Lens' RegisterPackageVersion Prelude.Text
registerPackageVersion_patchVersion :: Lens' RegisterPackageVersion Text
registerPackageVersion_patchVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterPackageVersion' {Text
patchVersion :: Text
$sel:patchVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
patchVersion} -> Text
patchVersion) (\s :: RegisterPackageVersion
s@RegisterPackageVersion' {} Text
a -> RegisterPackageVersion
s {$sel:patchVersion:RegisterPackageVersion' :: Text
patchVersion = Text
a} :: RegisterPackageVersion)

instance Core.AWSRequest RegisterPackageVersion where
  type
    AWSResponse RegisterPackageVersion =
      RegisterPackageVersionResponse
  request :: (Service -> Service)
-> RegisterPackageVersion -> Request RegisterPackageVersion
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.putJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy RegisterPackageVersion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RegisterPackageVersion)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> RegisterPackageVersionResponse
RegisterPackageVersionResponse'
            forall (f :: * -> *) a b. Functor 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 RegisterPackageVersion where
  hashWithSalt :: Int -> RegisterPackageVersion -> Int
hashWithSalt Int
_salt RegisterPackageVersion' {Maybe Bool
Maybe Text
Text
patchVersion :: Text
packageVersion :: Text
packageId :: Text
ownerAccount :: Maybe Text
markLatest :: Maybe Bool
$sel:patchVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageId:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:ownerAccount:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Text
$sel:markLatest:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
markLatest
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
ownerAccount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
packageId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
packageVersion
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
patchVersion

instance Prelude.NFData RegisterPackageVersion where
  rnf :: RegisterPackageVersion -> ()
rnf RegisterPackageVersion' {Maybe Bool
Maybe Text
Text
patchVersion :: Text
packageVersion :: Text
packageId :: Text
ownerAccount :: Maybe Text
markLatest :: Maybe Bool
$sel:patchVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageId:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:ownerAccount:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Text
$sel:markLatest:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
markLatest
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
ownerAccount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
packageId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
packageVersion
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
patchVersion

instance Data.ToHeaders RegisterPackageVersion where
  toHeaders :: RegisterPackageVersion -> 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 RegisterPackageVersion where
  toJSON :: RegisterPackageVersion -> Value
toJSON RegisterPackageVersion' {Maybe Bool
Maybe Text
Text
patchVersion :: Text
packageVersion :: Text
packageId :: Text
ownerAccount :: Maybe Text
markLatest :: Maybe Bool
$sel:patchVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageId:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:ownerAccount:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Text
$sel:markLatest:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"MarkLatest" 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 Bool
markLatest,
            (Key
"OwnerAccount" 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
ownerAccount
          ]
      )

instance Data.ToPath RegisterPackageVersion where
  toPath :: RegisterPackageVersion -> ByteString
toPath RegisterPackageVersion' {Maybe Bool
Maybe Text
Text
patchVersion :: Text
packageVersion :: Text
packageId :: Text
ownerAccount :: Maybe Text
markLatest :: Maybe Bool
$sel:patchVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageVersion:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:packageId:RegisterPackageVersion' :: RegisterPackageVersion -> Text
$sel:ownerAccount:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Text
$sel:markLatest:RegisterPackageVersion' :: RegisterPackageVersion -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/packages/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
packageId,
        ByteString
"/versions/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
packageVersion,
        ByteString
"/patch/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
patchVersion
      ]

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

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

-- |
-- Create a value of 'RegisterPackageVersionResponse' 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:
--
-- 'httpStatus', 'registerPackageVersionResponse_httpStatus' - The response's http status code.
newRegisterPackageVersionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RegisterPackageVersionResponse
newRegisterPackageVersionResponse :: Int -> RegisterPackageVersionResponse
newRegisterPackageVersionResponse Int
pHttpStatus_ =
  RegisterPackageVersionResponse'
    { $sel:httpStatus:RegisterPackageVersionResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance
  Prelude.NFData
    RegisterPackageVersionResponse
  where
  rnf :: RegisterPackageVersionResponse -> ()
rnf RegisterPackageVersionResponse' {Int
httpStatus :: Int
$sel:httpStatus:RegisterPackageVersionResponse' :: RegisterPackageVersionResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus