{-# 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.CodeArtifact.UpdatePackageVersionsStatus
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates the status of one or more versions of a package. Using
-- @UpdatePackageVersionsStatus@, you can update the status of package
-- versions to @Archived@, @Published@, or @Unlisted@. To set the status of
-- a package version to @Disposed@, use
-- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DisposePackageVersions.html DisposePackageVersions>.
module Amazonka.CodeArtifact.UpdatePackageVersionsStatus
  ( -- * Creating a Request
    UpdatePackageVersionsStatus (..),
    newUpdatePackageVersionsStatus,

    -- * Request Lenses
    updatePackageVersionsStatus_domainOwner,
    updatePackageVersionsStatus_expectedStatus,
    updatePackageVersionsStatus_namespace,
    updatePackageVersionsStatus_versionRevisions,
    updatePackageVersionsStatus_domain,
    updatePackageVersionsStatus_repository,
    updatePackageVersionsStatus_format,
    updatePackageVersionsStatus_package,
    updatePackageVersionsStatus_versions,
    updatePackageVersionsStatus_targetStatus,

    -- * Destructuring the Response
    UpdatePackageVersionsStatusResponse (..),
    newUpdatePackageVersionsStatusResponse,

    -- * Response Lenses
    updatePackageVersionsStatusResponse_failedVersions,
    updatePackageVersionsStatusResponse_successfulVersions,
    updatePackageVersionsStatusResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdatePackageVersionsStatus' smart constructor.
data UpdatePackageVersionsStatus = UpdatePackageVersionsStatus'
  { -- | The 12-digit account number of the Amazon Web Services account that owns
    -- the domain. It does not include dashes or spaces.
    UpdatePackageVersionsStatus -> Maybe Text
domainOwner :: Prelude.Maybe Prelude.Text,
    -- | The package version’s expected status before it is updated. If
    -- @expectedStatus@ is provided, the package version\'s status is updated
    -- only if its status at the time @UpdatePackageVersionsStatus@ is called
    -- matches @expectedStatus@.
    UpdatePackageVersionsStatus -> Maybe PackageVersionStatus
expectedStatus :: Prelude.Maybe PackageVersionStatus,
    -- | The namespace of the package version to be updated. The package version
    -- component that specifies its namespace depends on its type. For example:
    --
    -- -   The namespace of a Maven package version is its @groupId@.
    --
    -- -   The namespace of an npm package version is its @scope@.
    --
    -- -   Python and NuGet package versions do not contain a corresponding
    --     component, package versions of those formats do not have a
    --     namespace.
    UpdatePackageVersionsStatus -> Maybe Text
namespace :: Prelude.Maybe Prelude.Text,
    -- | A map of package versions and package version revisions. The map @key@
    -- is the package version (for example, @3.5.2@), and the map @value@ is
    -- the package version revision.
    UpdatePackageVersionsStatus -> Maybe (HashMap Text Text)
versionRevisions :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The name of the domain that contains the repository that contains the
    -- package versions with a status to be updated.
    UpdatePackageVersionsStatus -> Text
domain :: Prelude.Text,
    -- | The repository that contains the package versions with the status you
    -- want to update.
    UpdatePackageVersionsStatus -> Text
repository :: Prelude.Text,
    -- | A format that specifies the type of the package with the statuses to
    -- update.
    UpdatePackageVersionsStatus -> PackageFormat
format :: PackageFormat,
    -- | The name of the package with the version statuses to update.
    UpdatePackageVersionsStatus -> Text
package :: Prelude.Text,
    -- | An array of strings that specify the versions of the package with the
    -- statuses to update.
    UpdatePackageVersionsStatus -> [Text]
versions :: [Prelude.Text],
    -- | The status you want to change the package version status to.
    UpdatePackageVersionsStatus -> PackageVersionStatus
targetStatus :: PackageVersionStatus
  }
  deriving (UpdatePackageVersionsStatus -> UpdatePackageVersionsStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdatePackageVersionsStatus -> UpdatePackageVersionsStatus -> Bool
$c/= :: UpdatePackageVersionsStatus -> UpdatePackageVersionsStatus -> Bool
== :: UpdatePackageVersionsStatus -> UpdatePackageVersionsStatus -> Bool
$c== :: UpdatePackageVersionsStatus -> UpdatePackageVersionsStatus -> Bool
Prelude.Eq, ReadPrec [UpdatePackageVersionsStatus]
ReadPrec UpdatePackageVersionsStatus
Int -> ReadS UpdatePackageVersionsStatus
ReadS [UpdatePackageVersionsStatus]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdatePackageVersionsStatus]
$creadListPrec :: ReadPrec [UpdatePackageVersionsStatus]
readPrec :: ReadPrec UpdatePackageVersionsStatus
$creadPrec :: ReadPrec UpdatePackageVersionsStatus
readList :: ReadS [UpdatePackageVersionsStatus]
$creadList :: ReadS [UpdatePackageVersionsStatus]
readsPrec :: Int -> ReadS UpdatePackageVersionsStatus
$creadsPrec :: Int -> ReadS UpdatePackageVersionsStatus
Prelude.Read, Int -> UpdatePackageVersionsStatus -> ShowS
[UpdatePackageVersionsStatus] -> ShowS
UpdatePackageVersionsStatus -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdatePackageVersionsStatus] -> ShowS
$cshowList :: [UpdatePackageVersionsStatus] -> ShowS
show :: UpdatePackageVersionsStatus -> String
$cshow :: UpdatePackageVersionsStatus -> String
showsPrec :: Int -> UpdatePackageVersionsStatus -> ShowS
$cshowsPrec :: Int -> UpdatePackageVersionsStatus -> ShowS
Prelude.Show, forall x.
Rep UpdatePackageVersionsStatus x -> UpdatePackageVersionsStatus
forall x.
UpdatePackageVersionsStatus -> Rep UpdatePackageVersionsStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdatePackageVersionsStatus x -> UpdatePackageVersionsStatus
$cfrom :: forall x.
UpdatePackageVersionsStatus -> Rep UpdatePackageVersionsStatus x
Prelude.Generic)

-- |
-- Create a value of 'UpdatePackageVersionsStatus' 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:
--
-- 'domainOwner', 'updatePackageVersionsStatus_domainOwner' - The 12-digit account number of the Amazon Web Services account that owns
-- the domain. It does not include dashes or spaces.
--
-- 'expectedStatus', 'updatePackageVersionsStatus_expectedStatus' - The package version’s expected status before it is updated. If
-- @expectedStatus@ is provided, the package version\'s status is updated
-- only if its status at the time @UpdatePackageVersionsStatus@ is called
-- matches @expectedStatus@.
--
-- 'namespace', 'updatePackageVersionsStatus_namespace' - The namespace of the package version to be updated. The package version
-- component that specifies its namespace depends on its type. For example:
--
-- -   The namespace of a Maven package version is its @groupId@.
--
-- -   The namespace of an npm package version is its @scope@.
--
-- -   Python and NuGet package versions do not contain a corresponding
--     component, package versions of those formats do not have a
--     namespace.
--
-- 'versionRevisions', 'updatePackageVersionsStatus_versionRevisions' - A map of package versions and package version revisions. The map @key@
-- is the package version (for example, @3.5.2@), and the map @value@ is
-- the package version revision.
--
-- 'domain', 'updatePackageVersionsStatus_domain' - The name of the domain that contains the repository that contains the
-- package versions with a status to be updated.
--
-- 'repository', 'updatePackageVersionsStatus_repository' - The repository that contains the package versions with the status you
-- want to update.
--
-- 'format', 'updatePackageVersionsStatus_format' - A format that specifies the type of the package with the statuses to
-- update.
--
-- 'package', 'updatePackageVersionsStatus_package' - The name of the package with the version statuses to update.
--
-- 'versions', 'updatePackageVersionsStatus_versions' - An array of strings that specify the versions of the package with the
-- statuses to update.
--
-- 'targetStatus', 'updatePackageVersionsStatus_targetStatus' - The status you want to change the package version status to.
newUpdatePackageVersionsStatus ::
  -- | 'domain'
  Prelude.Text ->
  -- | 'repository'
  Prelude.Text ->
  -- | 'format'
  PackageFormat ->
  -- | 'package'
  Prelude.Text ->
  -- | 'targetStatus'
  PackageVersionStatus ->
  UpdatePackageVersionsStatus
newUpdatePackageVersionsStatus :: Text
-> Text
-> PackageFormat
-> Text
-> PackageVersionStatus
-> UpdatePackageVersionsStatus
newUpdatePackageVersionsStatus
  Text
pDomain_
  Text
pRepository_
  PackageFormat
pFormat_
  Text
pPackage_
  PackageVersionStatus
pTargetStatus_ =
    UpdatePackageVersionsStatus'
      { $sel:domainOwner:UpdatePackageVersionsStatus' :: Maybe Text
domainOwner =
          forall a. Maybe a
Prelude.Nothing,
        $sel:expectedStatus:UpdatePackageVersionsStatus' :: Maybe PackageVersionStatus
expectedStatus = forall a. Maybe a
Prelude.Nothing,
        $sel:namespace:UpdatePackageVersionsStatus' :: Maybe Text
namespace = forall a. Maybe a
Prelude.Nothing,
        $sel:versionRevisions:UpdatePackageVersionsStatus' :: Maybe (HashMap Text Text)
versionRevisions = forall a. Maybe a
Prelude.Nothing,
        $sel:domain:UpdatePackageVersionsStatus' :: Text
domain = Text
pDomain_,
        $sel:repository:UpdatePackageVersionsStatus' :: Text
repository = Text
pRepository_,
        $sel:format:UpdatePackageVersionsStatus' :: PackageFormat
format = PackageFormat
pFormat_,
        $sel:package:UpdatePackageVersionsStatus' :: Text
package = Text
pPackage_,
        $sel:versions:UpdatePackageVersionsStatus' :: [Text]
versions = forall a. Monoid a => a
Prelude.mempty,
        $sel:targetStatus:UpdatePackageVersionsStatus' :: PackageVersionStatus
targetStatus = PackageVersionStatus
pTargetStatus_
      }

-- | The 12-digit account number of the Amazon Web Services account that owns
-- the domain. It does not include dashes or spaces.
updatePackageVersionsStatus_domainOwner :: Lens.Lens' UpdatePackageVersionsStatus (Prelude.Maybe Prelude.Text)
updatePackageVersionsStatus_domainOwner :: Lens' UpdatePackageVersionsStatus (Maybe Text)
updatePackageVersionsStatus_domainOwner = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {Maybe Text
domainOwner :: Maybe Text
$sel:domainOwner:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
domainOwner} -> Maybe Text
domainOwner) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} Maybe Text
a -> UpdatePackageVersionsStatus
s {$sel:domainOwner:UpdatePackageVersionsStatus' :: Maybe Text
domainOwner = Maybe Text
a} :: UpdatePackageVersionsStatus)

-- | The package version’s expected status before it is updated. If
-- @expectedStatus@ is provided, the package version\'s status is updated
-- only if its status at the time @UpdatePackageVersionsStatus@ is called
-- matches @expectedStatus@.
updatePackageVersionsStatus_expectedStatus :: Lens.Lens' UpdatePackageVersionsStatus (Prelude.Maybe PackageVersionStatus)
updatePackageVersionsStatus_expectedStatus :: Lens' UpdatePackageVersionsStatus (Maybe PackageVersionStatus)
updatePackageVersionsStatus_expectedStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {Maybe PackageVersionStatus
expectedStatus :: Maybe PackageVersionStatus
$sel:expectedStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe PackageVersionStatus
expectedStatus} -> Maybe PackageVersionStatus
expectedStatus) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} Maybe PackageVersionStatus
a -> UpdatePackageVersionsStatus
s {$sel:expectedStatus:UpdatePackageVersionsStatus' :: Maybe PackageVersionStatus
expectedStatus = Maybe PackageVersionStatus
a} :: UpdatePackageVersionsStatus)

-- | The namespace of the package version to be updated. The package version
-- component that specifies its namespace depends on its type. For example:
--
-- -   The namespace of a Maven package version is its @groupId@.
--
-- -   The namespace of an npm package version is its @scope@.
--
-- -   Python and NuGet package versions do not contain a corresponding
--     component, package versions of those formats do not have a
--     namespace.
updatePackageVersionsStatus_namespace :: Lens.Lens' UpdatePackageVersionsStatus (Prelude.Maybe Prelude.Text)
updatePackageVersionsStatus_namespace :: Lens' UpdatePackageVersionsStatus (Maybe Text)
updatePackageVersionsStatus_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {Maybe Text
namespace :: Maybe Text
$sel:namespace:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
namespace} -> Maybe Text
namespace) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} Maybe Text
a -> UpdatePackageVersionsStatus
s {$sel:namespace:UpdatePackageVersionsStatus' :: Maybe Text
namespace = Maybe Text
a} :: UpdatePackageVersionsStatus)

-- | A map of package versions and package version revisions. The map @key@
-- is the package version (for example, @3.5.2@), and the map @value@ is
-- the package version revision.
updatePackageVersionsStatus_versionRevisions :: Lens.Lens' UpdatePackageVersionsStatus (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
updatePackageVersionsStatus_versionRevisions :: Lens' UpdatePackageVersionsStatus (Maybe (HashMap Text Text))
updatePackageVersionsStatus_versionRevisions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {Maybe (HashMap Text Text)
versionRevisions :: Maybe (HashMap Text Text)
$sel:versionRevisions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe (HashMap Text Text)
versionRevisions} -> Maybe (HashMap Text Text)
versionRevisions) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} Maybe (HashMap Text Text)
a -> UpdatePackageVersionsStatus
s {$sel:versionRevisions:UpdatePackageVersionsStatus' :: Maybe (HashMap Text Text)
versionRevisions = Maybe (HashMap Text Text)
a} :: UpdatePackageVersionsStatus) 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 name of the domain that contains the repository that contains the
-- package versions with a status to be updated.
updatePackageVersionsStatus_domain :: Lens.Lens' UpdatePackageVersionsStatus Prelude.Text
updatePackageVersionsStatus_domain :: Lens' UpdatePackageVersionsStatus Text
updatePackageVersionsStatus_domain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {Text
domain :: Text
$sel:domain:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
domain} -> Text
domain) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} Text
a -> UpdatePackageVersionsStatus
s {$sel:domain:UpdatePackageVersionsStatus' :: Text
domain = Text
a} :: UpdatePackageVersionsStatus)

-- | The repository that contains the package versions with the status you
-- want to update.
updatePackageVersionsStatus_repository :: Lens.Lens' UpdatePackageVersionsStatus Prelude.Text
updatePackageVersionsStatus_repository :: Lens' UpdatePackageVersionsStatus Text
updatePackageVersionsStatus_repository = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {Text
repository :: Text
$sel:repository:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
repository} -> Text
repository) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} Text
a -> UpdatePackageVersionsStatus
s {$sel:repository:UpdatePackageVersionsStatus' :: Text
repository = Text
a} :: UpdatePackageVersionsStatus)

-- | A format that specifies the type of the package with the statuses to
-- update.
updatePackageVersionsStatus_format :: Lens.Lens' UpdatePackageVersionsStatus PackageFormat
updatePackageVersionsStatus_format :: Lens' UpdatePackageVersionsStatus PackageFormat
updatePackageVersionsStatus_format = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {PackageFormat
format :: PackageFormat
$sel:format:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageFormat
format} -> PackageFormat
format) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} PackageFormat
a -> UpdatePackageVersionsStatus
s {$sel:format:UpdatePackageVersionsStatus' :: PackageFormat
format = PackageFormat
a} :: UpdatePackageVersionsStatus)

-- | The name of the package with the version statuses to update.
updatePackageVersionsStatus_package :: Lens.Lens' UpdatePackageVersionsStatus Prelude.Text
updatePackageVersionsStatus_package :: Lens' UpdatePackageVersionsStatus Text
updatePackageVersionsStatus_package = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {Text
package :: Text
$sel:package:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
package} -> Text
package) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} Text
a -> UpdatePackageVersionsStatus
s {$sel:package:UpdatePackageVersionsStatus' :: Text
package = Text
a} :: UpdatePackageVersionsStatus)

-- | An array of strings that specify the versions of the package with the
-- statuses to update.
updatePackageVersionsStatus_versions :: Lens.Lens' UpdatePackageVersionsStatus [Prelude.Text]
updatePackageVersionsStatus_versions :: Lens' UpdatePackageVersionsStatus [Text]
updatePackageVersionsStatus_versions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {[Text]
versions :: [Text]
$sel:versions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> [Text]
versions} -> [Text]
versions) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} [Text]
a -> UpdatePackageVersionsStatus
s {$sel:versions:UpdatePackageVersionsStatus' :: [Text]
versions = [Text]
a} :: UpdatePackageVersionsStatus) 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

-- | The status you want to change the package version status to.
updatePackageVersionsStatus_targetStatus :: Lens.Lens' UpdatePackageVersionsStatus PackageVersionStatus
updatePackageVersionsStatus_targetStatus :: Lens' UpdatePackageVersionsStatus PackageVersionStatus
updatePackageVersionsStatus_targetStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatus' {PackageVersionStatus
targetStatus :: PackageVersionStatus
$sel:targetStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageVersionStatus
targetStatus} -> PackageVersionStatus
targetStatus) (\s :: UpdatePackageVersionsStatus
s@UpdatePackageVersionsStatus' {} PackageVersionStatus
a -> UpdatePackageVersionsStatus
s {$sel:targetStatus:UpdatePackageVersionsStatus' :: PackageVersionStatus
targetStatus = PackageVersionStatus
a} :: UpdatePackageVersionsStatus)

instance Core.AWSRequest UpdatePackageVersionsStatus where
  type
    AWSResponse UpdatePackageVersionsStatus =
      UpdatePackageVersionsStatusResponse
  request :: (Service -> Service)
-> UpdatePackageVersionsStatus
-> Request UpdatePackageVersionsStatus
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 UpdatePackageVersionsStatus
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdatePackageVersionsStatus)))
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 (HashMap Text PackageVersionError)
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
-> Int
-> UpdatePackageVersionsStatusResponse
UpdatePackageVersionsStatusResponse'
            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
"failedVersions" 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
"successfulVersions"
                            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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable UpdatePackageVersionsStatus where
  hashWithSalt :: Int -> UpdatePackageVersionsStatus -> Int
hashWithSalt Int
_salt UpdatePackageVersionsStatus' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
PackageVersionStatus
targetStatus :: PackageVersionStatus
versions :: [Text]
package :: Text
format :: PackageFormat
repository :: Text
domain :: Text
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
expectedStatus :: Maybe PackageVersionStatus
domainOwner :: Maybe Text
$sel:targetStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageVersionStatus
$sel:versions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> [Text]
$sel:package:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:format:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageFormat
$sel:repository:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:domain:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:versionRevisions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe (HashMap Text Text)
$sel:namespace:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
$sel:expectedStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe PackageVersionStatus
$sel:domainOwner:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
domainOwner
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PackageVersionStatus
expectedStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
namespace
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
versionRevisions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domain
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
repository
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` PackageFormat
format
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
package
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
versions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` PackageVersionStatus
targetStatus

instance Prelude.NFData UpdatePackageVersionsStatus where
  rnf :: UpdatePackageVersionsStatus -> ()
rnf UpdatePackageVersionsStatus' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
PackageVersionStatus
targetStatus :: PackageVersionStatus
versions :: [Text]
package :: Text
format :: PackageFormat
repository :: Text
domain :: Text
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
expectedStatus :: Maybe PackageVersionStatus
domainOwner :: Maybe Text
$sel:targetStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageVersionStatus
$sel:versions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> [Text]
$sel:package:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:format:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageFormat
$sel:repository:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:domain:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:versionRevisions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe (HashMap Text Text)
$sel:namespace:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
$sel:expectedStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe PackageVersionStatus
$sel:domainOwner:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
domainOwner
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PackageVersionStatus
expectedStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
namespace
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
versionRevisions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
domain
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
repository
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf PackageFormat
format
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
package
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
versions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf PackageVersionStatus
targetStatus

instance Data.ToHeaders UpdatePackageVersionsStatus where
  toHeaders :: UpdatePackageVersionsStatus -> 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 UpdatePackageVersionsStatus where
  toJSON :: UpdatePackageVersionsStatus -> Value
toJSON UpdatePackageVersionsStatus' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
PackageVersionStatus
targetStatus :: PackageVersionStatus
versions :: [Text]
package :: Text
format :: PackageFormat
repository :: Text
domain :: Text
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
expectedStatus :: Maybe PackageVersionStatus
domainOwner :: Maybe Text
$sel:targetStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageVersionStatus
$sel:versions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> [Text]
$sel:package:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:format:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageFormat
$sel:repository:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:domain:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:versionRevisions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe (HashMap Text Text)
$sel:namespace:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
$sel:expectedStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe PackageVersionStatus
$sel:domainOwner:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"expectedStatus" 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 PackageVersionStatus
expectedStatus,
            (Key
"versionRevisions" 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 (HashMap Text Text)
versionRevisions,
            forall a. a -> Maybe a
Prelude.Just (Key
"versions" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Text]
versions),
            forall a. a -> Maybe a
Prelude.Just (Key
"targetStatus" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= PackageVersionStatus
targetStatus)
          ]
      )

instance Data.ToPath UpdatePackageVersionsStatus where
  toPath :: UpdatePackageVersionsStatus -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const ByteString
"/v1/package/versions/update_status"

instance Data.ToQuery UpdatePackageVersionsStatus where
  toQuery :: UpdatePackageVersionsStatus -> QueryString
toQuery UpdatePackageVersionsStatus' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
PackageVersionStatus
targetStatus :: PackageVersionStatus
versions :: [Text]
package :: Text
format :: PackageFormat
repository :: Text
domain :: Text
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
expectedStatus :: Maybe PackageVersionStatus
domainOwner :: Maybe Text
$sel:targetStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageVersionStatus
$sel:versions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> [Text]
$sel:package:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:format:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> PackageFormat
$sel:repository:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:domain:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Text
$sel:versionRevisions:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe (HashMap Text Text)
$sel:namespace:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
$sel:expectedStatus:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe PackageVersionStatus
$sel:domainOwner:UpdatePackageVersionsStatus' :: UpdatePackageVersionsStatus -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"domain-owner" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
domainOwner,
        ByteString
"namespace" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
namespace,
        ByteString
"domain" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
domain,
        ByteString
"repository" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
repository,
        ByteString
"format" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: PackageFormat
format,
        ByteString
"package" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
package
      ]

-- | /See:/ 'newUpdatePackageVersionsStatusResponse' smart constructor.
data UpdatePackageVersionsStatusResponse = UpdatePackageVersionsStatusResponse'
  { -- | A list of @SuccessfulPackageVersionInfo@ objects, one for each package
    -- version with a status that successfully updated.
    UpdatePackageVersionsStatusResponse
-> Maybe (HashMap Text PackageVersionError)
failedVersions :: Prelude.Maybe (Prelude.HashMap Prelude.Text PackageVersionError),
    -- | A list of @PackageVersionError@ objects, one for each package version
    -- with a status that failed to update.
    UpdatePackageVersionsStatusResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions :: Prelude.Maybe (Prelude.HashMap Prelude.Text SuccessfulPackageVersionInfo),
    -- | The response's http status code.
    UpdatePackageVersionsStatusResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (UpdatePackageVersionsStatusResponse
-> UpdatePackageVersionsStatusResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdatePackageVersionsStatusResponse
-> UpdatePackageVersionsStatusResponse -> Bool
$c/= :: UpdatePackageVersionsStatusResponse
-> UpdatePackageVersionsStatusResponse -> Bool
== :: UpdatePackageVersionsStatusResponse
-> UpdatePackageVersionsStatusResponse -> Bool
$c== :: UpdatePackageVersionsStatusResponse
-> UpdatePackageVersionsStatusResponse -> Bool
Prelude.Eq, ReadPrec [UpdatePackageVersionsStatusResponse]
ReadPrec UpdatePackageVersionsStatusResponse
Int -> ReadS UpdatePackageVersionsStatusResponse
ReadS [UpdatePackageVersionsStatusResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdatePackageVersionsStatusResponse]
$creadListPrec :: ReadPrec [UpdatePackageVersionsStatusResponse]
readPrec :: ReadPrec UpdatePackageVersionsStatusResponse
$creadPrec :: ReadPrec UpdatePackageVersionsStatusResponse
readList :: ReadS [UpdatePackageVersionsStatusResponse]
$creadList :: ReadS [UpdatePackageVersionsStatusResponse]
readsPrec :: Int -> ReadS UpdatePackageVersionsStatusResponse
$creadsPrec :: Int -> ReadS UpdatePackageVersionsStatusResponse
Prelude.Read, Int -> UpdatePackageVersionsStatusResponse -> ShowS
[UpdatePackageVersionsStatusResponse] -> ShowS
UpdatePackageVersionsStatusResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdatePackageVersionsStatusResponse] -> ShowS
$cshowList :: [UpdatePackageVersionsStatusResponse] -> ShowS
show :: UpdatePackageVersionsStatusResponse -> String
$cshow :: UpdatePackageVersionsStatusResponse -> String
showsPrec :: Int -> UpdatePackageVersionsStatusResponse -> ShowS
$cshowsPrec :: Int -> UpdatePackageVersionsStatusResponse -> ShowS
Prelude.Show, forall x.
Rep UpdatePackageVersionsStatusResponse x
-> UpdatePackageVersionsStatusResponse
forall x.
UpdatePackageVersionsStatusResponse
-> Rep UpdatePackageVersionsStatusResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep UpdatePackageVersionsStatusResponse x
-> UpdatePackageVersionsStatusResponse
$cfrom :: forall x.
UpdatePackageVersionsStatusResponse
-> Rep UpdatePackageVersionsStatusResponse x
Prelude.Generic)

-- |
-- Create a value of 'UpdatePackageVersionsStatusResponse' 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:
--
-- 'failedVersions', 'updatePackageVersionsStatusResponse_failedVersions' - A list of @SuccessfulPackageVersionInfo@ objects, one for each package
-- version with a status that successfully updated.
--
-- 'successfulVersions', 'updatePackageVersionsStatusResponse_successfulVersions' - A list of @PackageVersionError@ objects, one for each package version
-- with a status that failed to update.
--
-- 'httpStatus', 'updatePackageVersionsStatusResponse_httpStatus' - The response's http status code.
newUpdatePackageVersionsStatusResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdatePackageVersionsStatusResponse
newUpdatePackageVersionsStatusResponse :: Int -> UpdatePackageVersionsStatusResponse
newUpdatePackageVersionsStatusResponse Int
pHttpStatus_ =
  UpdatePackageVersionsStatusResponse'
    { $sel:failedVersions:UpdatePackageVersionsStatusResponse' :: Maybe (HashMap Text PackageVersionError)
failedVersions =
        forall a. Maybe a
Prelude.Nothing,
      $sel:successfulVersions:UpdatePackageVersionsStatusResponse' :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdatePackageVersionsStatusResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of @SuccessfulPackageVersionInfo@ objects, one for each package
-- version with a status that successfully updated.
updatePackageVersionsStatusResponse_failedVersions :: Lens.Lens' UpdatePackageVersionsStatusResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text PackageVersionError))
updatePackageVersionsStatusResponse_failedVersions :: Lens'
  UpdatePackageVersionsStatusResponse
  (Maybe (HashMap Text PackageVersionError))
updatePackageVersionsStatusResponse_failedVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatusResponse' {Maybe (HashMap Text PackageVersionError)
failedVersions :: Maybe (HashMap Text PackageVersionError)
$sel:failedVersions:UpdatePackageVersionsStatusResponse' :: UpdatePackageVersionsStatusResponse
-> Maybe (HashMap Text PackageVersionError)
failedVersions} -> Maybe (HashMap Text PackageVersionError)
failedVersions) (\s :: UpdatePackageVersionsStatusResponse
s@UpdatePackageVersionsStatusResponse' {} Maybe (HashMap Text PackageVersionError)
a -> UpdatePackageVersionsStatusResponse
s {$sel:failedVersions:UpdatePackageVersionsStatusResponse' :: Maybe (HashMap Text PackageVersionError)
failedVersions = Maybe (HashMap Text PackageVersionError)
a} :: UpdatePackageVersionsStatusResponse) 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 @PackageVersionError@ objects, one for each package version
-- with a status that failed to update.
updatePackageVersionsStatusResponse_successfulVersions :: Lens.Lens' UpdatePackageVersionsStatusResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text SuccessfulPackageVersionInfo))
updatePackageVersionsStatusResponse_successfulVersions :: Lens'
  UpdatePackageVersionsStatusResponse
  (Maybe (HashMap Text SuccessfulPackageVersionInfo))
updatePackageVersionsStatusResponse_successfulVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatusResponse' {Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
$sel:successfulVersions:UpdatePackageVersionsStatusResponse' :: UpdatePackageVersionsStatusResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions} -> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions) (\s :: UpdatePackageVersionsStatusResponse
s@UpdatePackageVersionsStatusResponse' {} Maybe (HashMap Text SuccessfulPackageVersionInfo)
a -> UpdatePackageVersionsStatusResponse
s {$sel:successfulVersions:UpdatePackageVersionsStatusResponse' :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions = Maybe (HashMap Text SuccessfulPackageVersionInfo)
a} :: UpdatePackageVersionsStatusResponse) 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 response's http status code.
updatePackageVersionsStatusResponse_httpStatus :: Lens.Lens' UpdatePackageVersionsStatusResponse Prelude.Int
updatePackageVersionsStatusResponse_httpStatus :: Lens' UpdatePackageVersionsStatusResponse Int
updatePackageVersionsStatusResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdatePackageVersionsStatusResponse' {Int
httpStatus :: Int
$sel:httpStatus:UpdatePackageVersionsStatusResponse' :: UpdatePackageVersionsStatusResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: UpdatePackageVersionsStatusResponse
s@UpdatePackageVersionsStatusResponse' {} Int
a -> UpdatePackageVersionsStatusResponse
s {$sel:httpStatus:UpdatePackageVersionsStatusResponse' :: Int
httpStatus = Int
a} :: UpdatePackageVersionsStatusResponse)

instance
  Prelude.NFData
    UpdatePackageVersionsStatusResponse
  where
  rnf :: UpdatePackageVersionsStatusResponse -> ()
rnf UpdatePackageVersionsStatusResponse' {Int
Maybe (HashMap Text PackageVersionError)
Maybe (HashMap Text SuccessfulPackageVersionInfo)
httpStatus :: Int
successfulVersions :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
failedVersions :: Maybe (HashMap Text PackageVersionError)
$sel:httpStatus:UpdatePackageVersionsStatusResponse' :: UpdatePackageVersionsStatusResponse -> Int
$sel:successfulVersions:UpdatePackageVersionsStatusResponse' :: UpdatePackageVersionsStatusResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
$sel:failedVersions:UpdatePackageVersionsStatusResponse' :: UpdatePackageVersionsStatusResponse
-> Maybe (HashMap Text PackageVersionError)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text PackageVersionError)
failedVersions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus