{-# 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.CopyPackageVersions
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Copies package versions from one repository to another repository in the
-- same domain.
--
-- You must specify @versions@ or @versionRevisions@. You cannot specify
-- both.
module Amazonka.CodeArtifact.CopyPackageVersions
  ( -- * Creating a Request
    CopyPackageVersions (..),
    newCopyPackageVersions,

    -- * Request Lenses
    copyPackageVersions_allowOverwrite,
    copyPackageVersions_domainOwner,
    copyPackageVersions_includeFromUpstream,
    copyPackageVersions_namespace,
    copyPackageVersions_versionRevisions,
    copyPackageVersions_versions,
    copyPackageVersions_domain,
    copyPackageVersions_sourceRepository,
    copyPackageVersions_destinationRepository,
    copyPackageVersions_format,
    copyPackageVersions_package,

    -- * Destructuring the Response
    CopyPackageVersionsResponse (..),
    newCopyPackageVersionsResponse,

    -- * Response Lenses
    copyPackageVersionsResponse_failedVersions,
    copyPackageVersionsResponse_successfulVersions,
    copyPackageVersionsResponse_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:/ 'newCopyPackageVersions' smart constructor.
data CopyPackageVersions = CopyPackageVersions'
  { -- | Set to true to overwrite a package version that already exists in the
    -- destination repository. If set to false and the package version already
    -- exists in the destination repository, the package version is returned in
    -- the @failedVersions@ field of the response with an @ALREADY_EXISTS@
    -- error code.
    CopyPackageVersions -> Maybe Bool
allowOverwrite :: Prelude.Maybe Prelude.Bool,
    -- | The 12-digit account number of the Amazon Web Services account that owns
    -- the domain. It does not include dashes or spaces.
    CopyPackageVersions -> Maybe Text
domainOwner :: Prelude.Maybe Prelude.Text,
    -- | Set to true to copy packages from repositories that are upstream from
    -- the source repository to the destination repository. The default setting
    -- is false. For more information, see
    -- <https://docs.aws.amazon.com/codeartifact/latest/ug/repos-upstream.html Working with upstream repositories>.
    CopyPackageVersions -> Maybe Bool
includeFromUpstream :: Prelude.Maybe Prelude.Bool,
    -- | The namespace of the package versions to be copied. 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 is required when copying Maven package versions.
    --
    -- -   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.
    CopyPackageVersions -> Maybe Text
namespace :: Prelude.Maybe Prelude.Text,
    -- | A list of key-value pairs. The keys are package versions and the values
    -- are package version revisions. A @CopyPackageVersion@ operation succeeds
    -- if the specified versions in the source repository match the specified
    -- package version revision.
    --
    -- You must specify @versions@ or @versionRevisions@. You cannot specify
    -- both.
    CopyPackageVersions -> Maybe (HashMap Text Text)
versionRevisions :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The versions of the package to be copied.
    --
    -- You must specify @versions@ or @versionRevisions@. You cannot specify
    -- both.
    CopyPackageVersions -> Maybe [Text]
versions :: Prelude.Maybe [Prelude.Text],
    -- | The name of the domain that contains the source and destination
    -- repositories.
    CopyPackageVersions -> Text
domain :: Prelude.Text,
    -- | The name of the repository that contains the package versions to be
    -- copied.
    CopyPackageVersions -> Text
sourceRepository :: Prelude.Text,
    -- | The name of the repository into which package versions are copied.
    CopyPackageVersions -> Text
destinationRepository :: Prelude.Text,
    -- | The format of the package versions to be copied.
    CopyPackageVersions -> PackageFormat
format :: PackageFormat,
    -- | The name of the package that contains the versions to be copied.
    CopyPackageVersions -> Text
package :: Prelude.Text
  }
  deriving (CopyPackageVersions -> CopyPackageVersions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyPackageVersions -> CopyPackageVersions -> Bool
$c/= :: CopyPackageVersions -> CopyPackageVersions -> Bool
== :: CopyPackageVersions -> CopyPackageVersions -> Bool
$c== :: CopyPackageVersions -> CopyPackageVersions -> Bool
Prelude.Eq, ReadPrec [CopyPackageVersions]
ReadPrec CopyPackageVersions
Int -> ReadS CopyPackageVersions
ReadS [CopyPackageVersions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CopyPackageVersions]
$creadListPrec :: ReadPrec [CopyPackageVersions]
readPrec :: ReadPrec CopyPackageVersions
$creadPrec :: ReadPrec CopyPackageVersions
readList :: ReadS [CopyPackageVersions]
$creadList :: ReadS [CopyPackageVersions]
readsPrec :: Int -> ReadS CopyPackageVersions
$creadsPrec :: Int -> ReadS CopyPackageVersions
Prelude.Read, Int -> CopyPackageVersions -> ShowS
[CopyPackageVersions] -> ShowS
CopyPackageVersions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyPackageVersions] -> ShowS
$cshowList :: [CopyPackageVersions] -> ShowS
show :: CopyPackageVersions -> String
$cshow :: CopyPackageVersions -> String
showsPrec :: Int -> CopyPackageVersions -> ShowS
$cshowsPrec :: Int -> CopyPackageVersions -> ShowS
Prelude.Show, forall x. Rep CopyPackageVersions x -> CopyPackageVersions
forall x. CopyPackageVersions -> Rep CopyPackageVersions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CopyPackageVersions x -> CopyPackageVersions
$cfrom :: forall x. CopyPackageVersions -> Rep CopyPackageVersions x
Prelude.Generic)

-- |
-- Create a value of 'CopyPackageVersions' 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:
--
-- 'allowOverwrite', 'copyPackageVersions_allowOverwrite' - Set to true to overwrite a package version that already exists in the
-- destination repository. If set to false and the package version already
-- exists in the destination repository, the package version is returned in
-- the @failedVersions@ field of the response with an @ALREADY_EXISTS@
-- error code.
--
-- 'domainOwner', 'copyPackageVersions_domainOwner' - The 12-digit account number of the Amazon Web Services account that owns
-- the domain. It does not include dashes or spaces.
--
-- 'includeFromUpstream', 'copyPackageVersions_includeFromUpstream' - Set to true to copy packages from repositories that are upstream from
-- the source repository to the destination repository. The default setting
-- is false. For more information, see
-- <https://docs.aws.amazon.com/codeartifact/latest/ug/repos-upstream.html Working with upstream repositories>.
--
-- 'namespace', 'copyPackageVersions_namespace' - The namespace of the package versions to be copied. 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 is required when copying Maven package versions.
--
-- -   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', 'copyPackageVersions_versionRevisions' - A list of key-value pairs. The keys are package versions and the values
-- are package version revisions. A @CopyPackageVersion@ operation succeeds
-- if the specified versions in the source repository match the specified
-- package version revision.
--
-- You must specify @versions@ or @versionRevisions@. You cannot specify
-- both.
--
-- 'versions', 'copyPackageVersions_versions' - The versions of the package to be copied.
--
-- You must specify @versions@ or @versionRevisions@. You cannot specify
-- both.
--
-- 'domain', 'copyPackageVersions_domain' - The name of the domain that contains the source and destination
-- repositories.
--
-- 'sourceRepository', 'copyPackageVersions_sourceRepository' - The name of the repository that contains the package versions to be
-- copied.
--
-- 'destinationRepository', 'copyPackageVersions_destinationRepository' - The name of the repository into which package versions are copied.
--
-- 'format', 'copyPackageVersions_format' - The format of the package versions to be copied.
--
-- 'package', 'copyPackageVersions_package' - The name of the package that contains the versions to be copied.
newCopyPackageVersions ::
  -- | 'domain'
  Prelude.Text ->
  -- | 'sourceRepository'
  Prelude.Text ->
  -- | 'destinationRepository'
  Prelude.Text ->
  -- | 'format'
  PackageFormat ->
  -- | 'package'
  Prelude.Text ->
  CopyPackageVersions
newCopyPackageVersions :: Text
-> Text -> Text -> PackageFormat -> Text -> CopyPackageVersions
newCopyPackageVersions
  Text
pDomain_
  Text
pSourceRepository_
  Text
pDestinationRepository_
  PackageFormat
pFormat_
  Text
pPackage_ =
    CopyPackageVersions'
      { $sel:allowOverwrite:CopyPackageVersions' :: Maybe Bool
allowOverwrite =
          forall a. Maybe a
Prelude.Nothing,
        $sel:domainOwner:CopyPackageVersions' :: Maybe Text
domainOwner = forall a. Maybe a
Prelude.Nothing,
        $sel:includeFromUpstream:CopyPackageVersions' :: Maybe Bool
includeFromUpstream = forall a. Maybe a
Prelude.Nothing,
        $sel:namespace:CopyPackageVersions' :: Maybe Text
namespace = forall a. Maybe a
Prelude.Nothing,
        $sel:versionRevisions:CopyPackageVersions' :: Maybe (HashMap Text Text)
versionRevisions = forall a. Maybe a
Prelude.Nothing,
        $sel:versions:CopyPackageVersions' :: Maybe [Text]
versions = forall a. Maybe a
Prelude.Nothing,
        $sel:domain:CopyPackageVersions' :: Text
domain = Text
pDomain_,
        $sel:sourceRepository:CopyPackageVersions' :: Text
sourceRepository = Text
pSourceRepository_,
        $sel:destinationRepository:CopyPackageVersions' :: Text
destinationRepository = Text
pDestinationRepository_,
        $sel:format:CopyPackageVersions' :: PackageFormat
format = PackageFormat
pFormat_,
        $sel:package:CopyPackageVersions' :: Text
package = Text
pPackage_
      }

-- | Set to true to overwrite a package version that already exists in the
-- destination repository. If set to false and the package version already
-- exists in the destination repository, the package version is returned in
-- the @failedVersions@ field of the response with an @ALREADY_EXISTS@
-- error code.
copyPackageVersions_allowOverwrite :: Lens.Lens' CopyPackageVersions (Prelude.Maybe Prelude.Bool)
copyPackageVersions_allowOverwrite :: Lens' CopyPackageVersions (Maybe Bool)
copyPackageVersions_allowOverwrite = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Maybe Bool
allowOverwrite :: Maybe Bool
$sel:allowOverwrite:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
allowOverwrite} -> Maybe Bool
allowOverwrite) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Maybe Bool
a -> CopyPackageVersions
s {$sel:allowOverwrite:CopyPackageVersions' :: Maybe Bool
allowOverwrite = Maybe Bool
a} :: CopyPackageVersions)

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

-- | Set to true to copy packages from repositories that are upstream from
-- the source repository to the destination repository. The default setting
-- is false. For more information, see
-- <https://docs.aws.amazon.com/codeartifact/latest/ug/repos-upstream.html Working with upstream repositories>.
copyPackageVersions_includeFromUpstream :: Lens.Lens' CopyPackageVersions (Prelude.Maybe Prelude.Bool)
copyPackageVersions_includeFromUpstream :: Lens' CopyPackageVersions (Maybe Bool)
copyPackageVersions_includeFromUpstream = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Maybe Bool
includeFromUpstream :: Maybe Bool
$sel:includeFromUpstream:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
includeFromUpstream} -> Maybe Bool
includeFromUpstream) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Maybe Bool
a -> CopyPackageVersions
s {$sel:includeFromUpstream:CopyPackageVersions' :: Maybe Bool
includeFromUpstream = Maybe Bool
a} :: CopyPackageVersions)

-- | The namespace of the package versions to be copied. 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 is required when copying Maven package versions.
--
-- -   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.
copyPackageVersions_namespace :: Lens.Lens' CopyPackageVersions (Prelude.Maybe Prelude.Text)
copyPackageVersions_namespace :: Lens' CopyPackageVersions (Maybe Text)
copyPackageVersions_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Maybe Text
namespace :: Maybe Text
$sel:namespace:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
namespace} -> Maybe Text
namespace) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Maybe Text
a -> CopyPackageVersions
s {$sel:namespace:CopyPackageVersions' :: Maybe Text
namespace = Maybe Text
a} :: CopyPackageVersions)

-- | A list of key-value pairs. The keys are package versions and the values
-- are package version revisions. A @CopyPackageVersion@ operation succeeds
-- if the specified versions in the source repository match the specified
-- package version revision.
--
-- You must specify @versions@ or @versionRevisions@. You cannot specify
-- both.
copyPackageVersions_versionRevisions :: Lens.Lens' CopyPackageVersions (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
copyPackageVersions_versionRevisions :: Lens' CopyPackageVersions (Maybe (HashMap Text Text))
copyPackageVersions_versionRevisions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Maybe (HashMap Text Text)
versionRevisions :: Maybe (HashMap Text Text)
$sel:versionRevisions:CopyPackageVersions' :: CopyPackageVersions -> Maybe (HashMap Text Text)
versionRevisions} -> Maybe (HashMap Text Text)
versionRevisions) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Maybe (HashMap Text Text)
a -> CopyPackageVersions
s {$sel:versionRevisions:CopyPackageVersions' :: Maybe (HashMap Text Text)
versionRevisions = Maybe (HashMap Text Text)
a} :: CopyPackageVersions) 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 versions of the package to be copied.
--
-- You must specify @versions@ or @versionRevisions@. You cannot specify
-- both.
copyPackageVersions_versions :: Lens.Lens' CopyPackageVersions (Prelude.Maybe [Prelude.Text])
copyPackageVersions_versions :: Lens' CopyPackageVersions (Maybe [Text])
copyPackageVersions_versions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Maybe [Text]
versions :: Maybe [Text]
$sel:versions:CopyPackageVersions' :: CopyPackageVersions -> Maybe [Text]
versions} -> Maybe [Text]
versions) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Maybe [Text]
a -> CopyPackageVersions
s {$sel:versions:CopyPackageVersions' :: Maybe [Text]
versions = Maybe [Text]
a} :: CopyPackageVersions) 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 source and destination
-- repositories.
copyPackageVersions_domain :: Lens.Lens' CopyPackageVersions Prelude.Text
copyPackageVersions_domain :: Lens' CopyPackageVersions Text
copyPackageVersions_domain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Text
domain :: Text
$sel:domain:CopyPackageVersions' :: CopyPackageVersions -> Text
domain} -> Text
domain) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Text
a -> CopyPackageVersions
s {$sel:domain:CopyPackageVersions' :: Text
domain = Text
a} :: CopyPackageVersions)

-- | The name of the repository that contains the package versions to be
-- copied.
copyPackageVersions_sourceRepository :: Lens.Lens' CopyPackageVersions Prelude.Text
copyPackageVersions_sourceRepository :: Lens' CopyPackageVersions Text
copyPackageVersions_sourceRepository = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Text
sourceRepository :: Text
$sel:sourceRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
sourceRepository} -> Text
sourceRepository) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Text
a -> CopyPackageVersions
s {$sel:sourceRepository:CopyPackageVersions' :: Text
sourceRepository = Text
a} :: CopyPackageVersions)

-- | The name of the repository into which package versions are copied.
copyPackageVersions_destinationRepository :: Lens.Lens' CopyPackageVersions Prelude.Text
copyPackageVersions_destinationRepository :: Lens' CopyPackageVersions Text
copyPackageVersions_destinationRepository = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Text
destinationRepository :: Text
$sel:destinationRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
destinationRepository} -> Text
destinationRepository) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Text
a -> CopyPackageVersions
s {$sel:destinationRepository:CopyPackageVersions' :: Text
destinationRepository = Text
a} :: CopyPackageVersions)

-- | The format of the package versions to be copied.
copyPackageVersions_format :: Lens.Lens' CopyPackageVersions PackageFormat
copyPackageVersions_format :: Lens' CopyPackageVersions PackageFormat
copyPackageVersions_format = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {PackageFormat
format :: PackageFormat
$sel:format:CopyPackageVersions' :: CopyPackageVersions -> PackageFormat
format} -> PackageFormat
format) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} PackageFormat
a -> CopyPackageVersions
s {$sel:format:CopyPackageVersions' :: PackageFormat
format = PackageFormat
a} :: CopyPackageVersions)

-- | The name of the package that contains the versions to be copied.
copyPackageVersions_package :: Lens.Lens' CopyPackageVersions Prelude.Text
copyPackageVersions_package :: Lens' CopyPackageVersions Text
copyPackageVersions_package = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersions' {Text
package :: Text
$sel:package:CopyPackageVersions' :: CopyPackageVersions -> Text
package} -> Text
package) (\s :: CopyPackageVersions
s@CopyPackageVersions' {} Text
a -> CopyPackageVersions
s {$sel:package:CopyPackageVersions' :: Text
package = Text
a} :: CopyPackageVersions)

instance Core.AWSRequest CopyPackageVersions where
  type
    AWSResponse CopyPackageVersions =
      CopyPackageVersionsResponse
  request :: (Service -> Service)
-> CopyPackageVersions -> Request CopyPackageVersions
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 CopyPackageVersions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CopyPackageVersions)))
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
-> CopyPackageVersionsResponse
CopyPackageVersionsResponse'
            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 CopyPackageVersions where
  hashWithSalt :: Int -> CopyPackageVersions -> Int
hashWithSalt Int
_salt CopyPackageVersions' {Maybe Bool
Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Text
PackageFormat
package :: Text
format :: PackageFormat
destinationRepository :: Text
sourceRepository :: Text
domain :: Text
versions :: Maybe [Text]
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
includeFromUpstream :: Maybe Bool
domainOwner :: Maybe Text
allowOverwrite :: Maybe Bool
$sel:package:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:format:CopyPackageVersions' :: CopyPackageVersions -> PackageFormat
$sel:destinationRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:sourceRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:domain:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:versions:CopyPackageVersions' :: CopyPackageVersions -> Maybe [Text]
$sel:versionRevisions:CopyPackageVersions' :: CopyPackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:includeFromUpstream:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
$sel:domainOwner:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:allowOverwrite:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
allowOverwrite
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
domainOwner
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
includeFromUpstream
      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` Maybe [Text]
versions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
domain
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sourceRepository
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
destinationRepository
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` PackageFormat
format
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
package

instance Prelude.NFData CopyPackageVersions where
  rnf :: CopyPackageVersions -> ()
rnf CopyPackageVersions' {Maybe Bool
Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Text
PackageFormat
package :: Text
format :: PackageFormat
destinationRepository :: Text
sourceRepository :: Text
domain :: Text
versions :: Maybe [Text]
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
includeFromUpstream :: Maybe Bool
domainOwner :: Maybe Text
allowOverwrite :: Maybe Bool
$sel:package:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:format:CopyPackageVersions' :: CopyPackageVersions -> PackageFormat
$sel:destinationRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:sourceRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:domain:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:versions:CopyPackageVersions' :: CopyPackageVersions -> Maybe [Text]
$sel:versionRevisions:CopyPackageVersions' :: CopyPackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:includeFromUpstream:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
$sel:domainOwner:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:allowOverwrite:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
allowOverwrite
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 Bool
includeFromUpstream
      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 Maybe [Text]
versions
      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
sourceRepository
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
destinationRepository
      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

instance Data.ToHeaders CopyPackageVersions where
  toHeaders :: CopyPackageVersions -> 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 CopyPackageVersions where
  toJSON :: CopyPackageVersions -> Value
toJSON CopyPackageVersions' {Maybe Bool
Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Text
PackageFormat
package :: Text
format :: PackageFormat
destinationRepository :: Text
sourceRepository :: Text
domain :: Text
versions :: Maybe [Text]
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
includeFromUpstream :: Maybe Bool
domainOwner :: Maybe Text
allowOverwrite :: Maybe Bool
$sel:package:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:format:CopyPackageVersions' :: CopyPackageVersions -> PackageFormat
$sel:destinationRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:sourceRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:domain:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:versions:CopyPackageVersions' :: CopyPackageVersions -> Maybe [Text]
$sel:versionRevisions:CopyPackageVersions' :: CopyPackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:includeFromUpstream:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
$sel:domainOwner:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:allowOverwrite:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"allowOverwrite" 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
allowOverwrite,
            (Key
"includeFromUpstream" 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
includeFromUpstream,
            (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,
            (Key
"versions" 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]
versions
          ]
      )

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

instance Data.ToQuery CopyPackageVersions where
  toQuery :: CopyPackageVersions -> QueryString
toQuery CopyPackageVersions' {Maybe Bool
Maybe [Text]
Maybe Text
Maybe (HashMap Text Text)
Text
PackageFormat
package :: Text
format :: PackageFormat
destinationRepository :: Text
sourceRepository :: Text
domain :: Text
versions :: Maybe [Text]
versionRevisions :: Maybe (HashMap Text Text)
namespace :: Maybe Text
includeFromUpstream :: Maybe Bool
domainOwner :: Maybe Text
allowOverwrite :: Maybe Bool
$sel:package:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:format:CopyPackageVersions' :: CopyPackageVersions -> PackageFormat
$sel:destinationRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:sourceRepository:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:domain:CopyPackageVersions' :: CopyPackageVersions -> Text
$sel:versions:CopyPackageVersions' :: CopyPackageVersions -> Maybe [Text]
$sel:versionRevisions:CopyPackageVersions' :: CopyPackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:includeFromUpstream:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
$sel:domainOwner:CopyPackageVersions' :: CopyPackageVersions -> Maybe Text
$sel:allowOverwrite:CopyPackageVersions' :: CopyPackageVersions -> Maybe Bool
..} =
    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
"source-repository" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
sourceRepository,
        ByteString
"destination-repository"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
destinationRepository,
        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:/ 'newCopyPackageVersionsResponse' smart constructor.
data CopyPackageVersionsResponse = CopyPackageVersionsResponse'
  { -- | A map of package versions that failed to copy and their error codes. The
    -- possible error codes are in the @PackageVersionError@ data type. They
    -- are:
    --
    -- -   @ALREADY_EXISTS@
    --
    -- -   @MISMATCHED_REVISION@
    --
    -- -   @MISMATCHED_STATUS@
    --
    -- -   @NOT_ALLOWED@
    --
    -- -   @NOT_FOUND@
    --
    -- -   @SKIPPED@
    CopyPackageVersionsResponse
-> Maybe (HashMap Text PackageVersionError)
failedVersions :: Prelude.Maybe (Prelude.HashMap Prelude.Text PackageVersionError),
    -- | A list of the package versions that were successfully copied to your
    -- repository.
    CopyPackageVersionsResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions :: Prelude.Maybe (Prelude.HashMap Prelude.Text SuccessfulPackageVersionInfo),
    -- | The response's http status code.
    CopyPackageVersionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CopyPackageVersionsResponse -> CopyPackageVersionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyPackageVersionsResponse -> CopyPackageVersionsResponse -> Bool
$c/= :: CopyPackageVersionsResponse -> CopyPackageVersionsResponse -> Bool
== :: CopyPackageVersionsResponse -> CopyPackageVersionsResponse -> Bool
$c== :: CopyPackageVersionsResponse -> CopyPackageVersionsResponse -> Bool
Prelude.Eq, ReadPrec [CopyPackageVersionsResponse]
ReadPrec CopyPackageVersionsResponse
Int -> ReadS CopyPackageVersionsResponse
ReadS [CopyPackageVersionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CopyPackageVersionsResponse]
$creadListPrec :: ReadPrec [CopyPackageVersionsResponse]
readPrec :: ReadPrec CopyPackageVersionsResponse
$creadPrec :: ReadPrec CopyPackageVersionsResponse
readList :: ReadS [CopyPackageVersionsResponse]
$creadList :: ReadS [CopyPackageVersionsResponse]
readsPrec :: Int -> ReadS CopyPackageVersionsResponse
$creadsPrec :: Int -> ReadS CopyPackageVersionsResponse
Prelude.Read, Int -> CopyPackageVersionsResponse -> ShowS
[CopyPackageVersionsResponse] -> ShowS
CopyPackageVersionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyPackageVersionsResponse] -> ShowS
$cshowList :: [CopyPackageVersionsResponse] -> ShowS
show :: CopyPackageVersionsResponse -> String
$cshow :: CopyPackageVersionsResponse -> String
showsPrec :: Int -> CopyPackageVersionsResponse -> ShowS
$cshowsPrec :: Int -> CopyPackageVersionsResponse -> ShowS
Prelude.Show, forall x.
Rep CopyPackageVersionsResponse x -> CopyPackageVersionsResponse
forall x.
CopyPackageVersionsResponse -> Rep CopyPackageVersionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CopyPackageVersionsResponse x -> CopyPackageVersionsResponse
$cfrom :: forall x.
CopyPackageVersionsResponse -> Rep CopyPackageVersionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'CopyPackageVersionsResponse' 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', 'copyPackageVersionsResponse_failedVersions' - A map of package versions that failed to copy and their error codes. The
-- possible error codes are in the @PackageVersionError@ data type. They
-- are:
--
-- -   @ALREADY_EXISTS@
--
-- -   @MISMATCHED_REVISION@
--
-- -   @MISMATCHED_STATUS@
--
-- -   @NOT_ALLOWED@
--
-- -   @NOT_FOUND@
--
-- -   @SKIPPED@
--
-- 'successfulVersions', 'copyPackageVersionsResponse_successfulVersions' - A list of the package versions that were successfully copied to your
-- repository.
--
-- 'httpStatus', 'copyPackageVersionsResponse_httpStatus' - The response's http status code.
newCopyPackageVersionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CopyPackageVersionsResponse
newCopyPackageVersionsResponse :: Int -> CopyPackageVersionsResponse
newCopyPackageVersionsResponse Int
pHttpStatus_ =
  CopyPackageVersionsResponse'
    { $sel:failedVersions:CopyPackageVersionsResponse' :: Maybe (HashMap Text PackageVersionError)
failedVersions =
        forall a. Maybe a
Prelude.Nothing,
      $sel:successfulVersions:CopyPackageVersionsResponse' :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CopyPackageVersionsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A map of package versions that failed to copy and their error codes. The
-- possible error codes are in the @PackageVersionError@ data type. They
-- are:
--
-- -   @ALREADY_EXISTS@
--
-- -   @MISMATCHED_REVISION@
--
-- -   @MISMATCHED_STATUS@
--
-- -   @NOT_ALLOWED@
--
-- -   @NOT_FOUND@
--
-- -   @SKIPPED@
copyPackageVersionsResponse_failedVersions :: Lens.Lens' CopyPackageVersionsResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text PackageVersionError))
copyPackageVersionsResponse_failedVersions :: Lens'
  CopyPackageVersionsResponse
  (Maybe (HashMap Text PackageVersionError))
copyPackageVersionsResponse_failedVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersionsResponse' {Maybe (HashMap Text PackageVersionError)
failedVersions :: Maybe (HashMap Text PackageVersionError)
$sel:failedVersions:CopyPackageVersionsResponse' :: CopyPackageVersionsResponse
-> Maybe (HashMap Text PackageVersionError)
failedVersions} -> Maybe (HashMap Text PackageVersionError)
failedVersions) (\s :: CopyPackageVersionsResponse
s@CopyPackageVersionsResponse' {} Maybe (HashMap Text PackageVersionError)
a -> CopyPackageVersionsResponse
s {$sel:failedVersions:CopyPackageVersionsResponse' :: Maybe (HashMap Text PackageVersionError)
failedVersions = Maybe (HashMap Text PackageVersionError)
a} :: CopyPackageVersionsResponse) 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 the package versions that were successfully copied to your
-- repository.
copyPackageVersionsResponse_successfulVersions :: Lens.Lens' CopyPackageVersionsResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text SuccessfulPackageVersionInfo))
copyPackageVersionsResponse_successfulVersions :: Lens'
  CopyPackageVersionsResponse
  (Maybe (HashMap Text SuccessfulPackageVersionInfo))
copyPackageVersionsResponse_successfulVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersionsResponse' {Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
$sel:successfulVersions:CopyPackageVersionsResponse' :: CopyPackageVersionsResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions} -> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions) (\s :: CopyPackageVersionsResponse
s@CopyPackageVersionsResponse' {} Maybe (HashMap Text SuccessfulPackageVersionInfo)
a -> CopyPackageVersionsResponse
s {$sel:successfulVersions:CopyPackageVersionsResponse' :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions = Maybe (HashMap Text SuccessfulPackageVersionInfo)
a} :: CopyPackageVersionsResponse) 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.
copyPackageVersionsResponse_httpStatus :: Lens.Lens' CopyPackageVersionsResponse Prelude.Int
copyPackageVersionsResponse_httpStatus :: Lens' CopyPackageVersionsResponse Int
copyPackageVersionsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyPackageVersionsResponse' {Int
httpStatus :: Int
$sel:httpStatus:CopyPackageVersionsResponse' :: CopyPackageVersionsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CopyPackageVersionsResponse
s@CopyPackageVersionsResponse' {} Int
a -> CopyPackageVersionsResponse
s {$sel:httpStatus:CopyPackageVersionsResponse' :: Int
httpStatus = Int
a} :: CopyPackageVersionsResponse)

instance Prelude.NFData CopyPackageVersionsResponse where
  rnf :: CopyPackageVersionsResponse -> ()
rnf CopyPackageVersionsResponse' {Int
Maybe (HashMap Text PackageVersionError)
Maybe (HashMap Text SuccessfulPackageVersionInfo)
httpStatus :: Int
successfulVersions :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
failedVersions :: Maybe (HashMap Text PackageVersionError)
$sel:httpStatus:CopyPackageVersionsResponse' :: CopyPackageVersionsResponse -> Int
$sel:successfulVersions:CopyPackageVersionsResponse' :: CopyPackageVersionsResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
$sel:failedVersions:CopyPackageVersionsResponse' :: CopyPackageVersionsResponse
-> 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