{-# 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.DisposePackageVersions
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes the assets in package versions and sets the package versions\'
-- status to @Disposed@. A disposed package version cannot be restored in
-- your repository because its assets are deleted.
--
-- To view all disposed package versions in a repository, use
-- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html ListPackageVersions>
-- and set the
-- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html#API_ListPackageVersions_RequestSyntax status>
-- parameter to @Disposed@.
--
-- To view information about a disposed package version, use
-- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DescribePackageVersion.html DescribePackageVersion>.
module Amazonka.CodeArtifact.DisposePackageVersions
  ( -- * Creating a Request
    DisposePackageVersions (..),
    newDisposePackageVersions,

    -- * Request Lenses
    disposePackageVersions_domainOwner,
    disposePackageVersions_expectedStatus,
    disposePackageVersions_namespace,
    disposePackageVersions_versionRevisions,
    disposePackageVersions_domain,
    disposePackageVersions_repository,
    disposePackageVersions_format,
    disposePackageVersions_package,
    disposePackageVersions_versions,

    -- * Destructuring the Response
    DisposePackageVersionsResponse (..),
    newDisposePackageVersionsResponse,

    -- * Response Lenses
    disposePackageVersionsResponse_failedVersions,
    disposePackageVersionsResponse_successfulVersions,
    disposePackageVersionsResponse_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:/ 'newDisposePackageVersions' smart constructor.
data DisposePackageVersions = DisposePackageVersions'
  { -- | The 12-digit account number of the Amazon Web Services account that owns
    -- the domain. It does not include dashes or spaces.
    DisposePackageVersions -> Maybe Text
domainOwner :: Prelude.Maybe Prelude.Text,
    -- | The expected status of the package version to dispose.
    DisposePackageVersions -> Maybe PackageVersionStatus
expectedStatus :: Prelude.Maybe PackageVersionStatus,
    -- | The namespace of the package versions to be disposed. 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.
    DisposePackageVersions -> Maybe Text
namespace :: Prelude.Maybe Prelude.Text,
    -- | The revisions of the package versions you want to dispose.
    DisposePackageVersions -> Maybe (HashMap Text Text)
versionRevisions :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The name of the domain that contains the repository you want to dispose.
    DisposePackageVersions -> Text
domain :: Prelude.Text,
    -- | The name of the repository that contains the package versions you want
    -- to dispose.
    DisposePackageVersions -> Text
repository :: Prelude.Text,
    -- | A format that specifies the type of package versions you want to
    -- dispose.
    DisposePackageVersions -> PackageFormat
format :: PackageFormat,
    -- | The name of the package with the versions you want to dispose.
    DisposePackageVersions -> Text
package :: Prelude.Text,
    -- | The versions of the package you want to dispose.
    DisposePackageVersions -> [Text]
versions :: [Prelude.Text]
  }
  deriving (DisposePackageVersions -> DisposePackageVersions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisposePackageVersions -> DisposePackageVersions -> Bool
$c/= :: DisposePackageVersions -> DisposePackageVersions -> Bool
== :: DisposePackageVersions -> DisposePackageVersions -> Bool
$c== :: DisposePackageVersions -> DisposePackageVersions -> Bool
Prelude.Eq, ReadPrec [DisposePackageVersions]
ReadPrec DisposePackageVersions
Int -> ReadS DisposePackageVersions
ReadS [DisposePackageVersions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DisposePackageVersions]
$creadListPrec :: ReadPrec [DisposePackageVersions]
readPrec :: ReadPrec DisposePackageVersions
$creadPrec :: ReadPrec DisposePackageVersions
readList :: ReadS [DisposePackageVersions]
$creadList :: ReadS [DisposePackageVersions]
readsPrec :: Int -> ReadS DisposePackageVersions
$creadsPrec :: Int -> ReadS DisposePackageVersions
Prelude.Read, Int -> DisposePackageVersions -> ShowS
[DisposePackageVersions] -> ShowS
DisposePackageVersions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DisposePackageVersions] -> ShowS
$cshowList :: [DisposePackageVersions] -> ShowS
show :: DisposePackageVersions -> String
$cshow :: DisposePackageVersions -> String
showsPrec :: Int -> DisposePackageVersions -> ShowS
$cshowsPrec :: Int -> DisposePackageVersions -> ShowS
Prelude.Show, forall x. Rep DisposePackageVersions x -> DisposePackageVersions
forall x. DisposePackageVersions -> Rep DisposePackageVersions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DisposePackageVersions x -> DisposePackageVersions
$cfrom :: forall x. DisposePackageVersions -> Rep DisposePackageVersions x
Prelude.Generic)

-- |
-- Create a value of 'DisposePackageVersions' 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', 'disposePackageVersions_domainOwner' - The 12-digit account number of the Amazon Web Services account that owns
-- the domain. It does not include dashes or spaces.
--
-- 'expectedStatus', 'disposePackageVersions_expectedStatus' - The expected status of the package version to dispose.
--
-- 'namespace', 'disposePackageVersions_namespace' - The namespace of the package versions to be disposed. 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', 'disposePackageVersions_versionRevisions' - The revisions of the package versions you want to dispose.
--
-- 'domain', 'disposePackageVersions_domain' - The name of the domain that contains the repository you want to dispose.
--
-- 'repository', 'disposePackageVersions_repository' - The name of the repository that contains the package versions you want
-- to dispose.
--
-- 'format', 'disposePackageVersions_format' - A format that specifies the type of package versions you want to
-- dispose.
--
-- 'package', 'disposePackageVersions_package' - The name of the package with the versions you want to dispose.
--
-- 'versions', 'disposePackageVersions_versions' - The versions of the package you want to dispose.
newDisposePackageVersions ::
  -- | 'domain'
  Prelude.Text ->
  -- | 'repository'
  Prelude.Text ->
  -- | 'format'
  PackageFormat ->
  -- | 'package'
  Prelude.Text ->
  DisposePackageVersions
newDisposePackageVersions :: Text -> Text -> PackageFormat -> Text -> DisposePackageVersions
newDisposePackageVersions
  Text
pDomain_
  Text
pRepository_
  PackageFormat
pFormat_
  Text
pPackage_ =
    DisposePackageVersions'
      { $sel:domainOwner:DisposePackageVersions' :: Maybe Text
domainOwner =
          forall a. Maybe a
Prelude.Nothing,
        $sel:expectedStatus:DisposePackageVersions' :: Maybe PackageVersionStatus
expectedStatus = forall a. Maybe a
Prelude.Nothing,
        $sel:namespace:DisposePackageVersions' :: Maybe Text
namespace = forall a. Maybe a
Prelude.Nothing,
        $sel:versionRevisions:DisposePackageVersions' :: Maybe (HashMap Text Text)
versionRevisions = forall a. Maybe a
Prelude.Nothing,
        $sel:domain:DisposePackageVersions' :: Text
domain = Text
pDomain_,
        $sel:repository:DisposePackageVersions' :: Text
repository = Text
pRepository_,
        $sel:format:DisposePackageVersions' :: PackageFormat
format = PackageFormat
pFormat_,
        $sel:package:DisposePackageVersions' :: Text
package = Text
pPackage_,
        $sel:versions:DisposePackageVersions' :: [Text]
versions = forall a. Monoid a => a
Prelude.mempty
      }

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

-- | The expected status of the package version to dispose.
disposePackageVersions_expectedStatus :: Lens.Lens' DisposePackageVersions (Prelude.Maybe PackageVersionStatus)
disposePackageVersions_expectedStatus :: Lens' DisposePackageVersions (Maybe PackageVersionStatus)
disposePackageVersions_expectedStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {Maybe PackageVersionStatus
expectedStatus :: Maybe PackageVersionStatus
$sel:expectedStatus:DisposePackageVersions' :: DisposePackageVersions -> Maybe PackageVersionStatus
expectedStatus} -> Maybe PackageVersionStatus
expectedStatus) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} Maybe PackageVersionStatus
a -> DisposePackageVersions
s {$sel:expectedStatus:DisposePackageVersions' :: Maybe PackageVersionStatus
expectedStatus = Maybe PackageVersionStatus
a} :: DisposePackageVersions)

-- | The namespace of the package versions to be disposed. 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.
disposePackageVersions_namespace :: Lens.Lens' DisposePackageVersions (Prelude.Maybe Prelude.Text)
disposePackageVersions_namespace :: Lens' DisposePackageVersions (Maybe Text)
disposePackageVersions_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {Maybe Text
namespace :: Maybe Text
$sel:namespace:DisposePackageVersions' :: DisposePackageVersions -> Maybe Text
namespace} -> Maybe Text
namespace) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} Maybe Text
a -> DisposePackageVersions
s {$sel:namespace:DisposePackageVersions' :: Maybe Text
namespace = Maybe Text
a} :: DisposePackageVersions)

-- | The revisions of the package versions you want to dispose.
disposePackageVersions_versionRevisions :: Lens.Lens' DisposePackageVersions (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
disposePackageVersions_versionRevisions :: Lens' DisposePackageVersions (Maybe (HashMap Text Text))
disposePackageVersions_versionRevisions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {Maybe (HashMap Text Text)
versionRevisions :: Maybe (HashMap Text Text)
$sel:versionRevisions:DisposePackageVersions' :: DisposePackageVersions -> Maybe (HashMap Text Text)
versionRevisions} -> Maybe (HashMap Text Text)
versionRevisions) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} Maybe (HashMap Text Text)
a -> DisposePackageVersions
s {$sel:versionRevisions:DisposePackageVersions' :: Maybe (HashMap Text Text)
versionRevisions = Maybe (HashMap Text Text)
a} :: DisposePackageVersions) 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 you want to dispose.
disposePackageVersions_domain :: Lens.Lens' DisposePackageVersions Prelude.Text
disposePackageVersions_domain :: Lens' DisposePackageVersions Text
disposePackageVersions_domain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {Text
domain :: Text
$sel:domain:DisposePackageVersions' :: DisposePackageVersions -> Text
domain} -> Text
domain) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} Text
a -> DisposePackageVersions
s {$sel:domain:DisposePackageVersions' :: Text
domain = Text
a} :: DisposePackageVersions)

-- | The name of the repository that contains the package versions you want
-- to dispose.
disposePackageVersions_repository :: Lens.Lens' DisposePackageVersions Prelude.Text
disposePackageVersions_repository :: Lens' DisposePackageVersions Text
disposePackageVersions_repository = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {Text
repository :: Text
$sel:repository:DisposePackageVersions' :: DisposePackageVersions -> Text
repository} -> Text
repository) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} Text
a -> DisposePackageVersions
s {$sel:repository:DisposePackageVersions' :: Text
repository = Text
a} :: DisposePackageVersions)

-- | A format that specifies the type of package versions you want to
-- dispose.
disposePackageVersions_format :: Lens.Lens' DisposePackageVersions PackageFormat
disposePackageVersions_format :: Lens' DisposePackageVersions PackageFormat
disposePackageVersions_format = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {PackageFormat
format :: PackageFormat
$sel:format:DisposePackageVersions' :: DisposePackageVersions -> PackageFormat
format} -> PackageFormat
format) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} PackageFormat
a -> DisposePackageVersions
s {$sel:format:DisposePackageVersions' :: PackageFormat
format = PackageFormat
a} :: DisposePackageVersions)

-- | The name of the package with the versions you want to dispose.
disposePackageVersions_package :: Lens.Lens' DisposePackageVersions Prelude.Text
disposePackageVersions_package :: Lens' DisposePackageVersions Text
disposePackageVersions_package = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {Text
package :: Text
$sel:package:DisposePackageVersions' :: DisposePackageVersions -> Text
package} -> Text
package) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} Text
a -> DisposePackageVersions
s {$sel:package:DisposePackageVersions' :: Text
package = Text
a} :: DisposePackageVersions)

-- | The versions of the package you want to dispose.
disposePackageVersions_versions :: Lens.Lens' DisposePackageVersions [Prelude.Text]
disposePackageVersions_versions :: Lens' DisposePackageVersions [Text]
disposePackageVersions_versions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersions' {[Text]
versions :: [Text]
$sel:versions:DisposePackageVersions' :: DisposePackageVersions -> [Text]
versions} -> [Text]
versions) (\s :: DisposePackageVersions
s@DisposePackageVersions' {} [Text]
a -> DisposePackageVersions
s {$sel:versions:DisposePackageVersions' :: [Text]
versions = [Text]
a} :: DisposePackageVersions) 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

instance Core.AWSRequest DisposePackageVersions where
  type
    AWSResponse DisposePackageVersions =
      DisposePackageVersionsResponse
  request :: (Service -> Service)
-> DisposePackageVersions -> Request DisposePackageVersions
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 DisposePackageVersions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DisposePackageVersions)))
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
-> DisposePackageVersionsResponse
DisposePackageVersionsResponse'
            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 DisposePackageVersions where
  hashWithSalt :: Int -> DisposePackageVersions -> Int
hashWithSalt Int
_salt DisposePackageVersions' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
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:versions:DisposePackageVersions' :: DisposePackageVersions -> [Text]
$sel:package:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:format:DisposePackageVersions' :: DisposePackageVersions -> PackageFormat
$sel:repository:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:domain:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:versionRevisions:DisposePackageVersions' :: DisposePackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:DisposePackageVersions' :: DisposePackageVersions -> Maybe Text
$sel:expectedStatus:DisposePackageVersions' :: DisposePackageVersions -> Maybe PackageVersionStatus
$sel:domainOwner:DisposePackageVersions' :: DisposePackageVersions -> 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

instance Prelude.NFData DisposePackageVersions where
  rnf :: DisposePackageVersions -> ()
rnf DisposePackageVersions' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
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:versions:DisposePackageVersions' :: DisposePackageVersions -> [Text]
$sel:package:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:format:DisposePackageVersions' :: DisposePackageVersions -> PackageFormat
$sel:repository:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:domain:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:versionRevisions:DisposePackageVersions' :: DisposePackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:DisposePackageVersions' :: DisposePackageVersions -> Maybe Text
$sel:expectedStatus:DisposePackageVersions' :: DisposePackageVersions -> Maybe PackageVersionStatus
$sel:domainOwner:DisposePackageVersions' :: DisposePackageVersions -> 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

instance Data.ToHeaders DisposePackageVersions where
  toHeaders :: DisposePackageVersions -> 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 DisposePackageVersions where
  toJSON :: DisposePackageVersions -> Value
toJSON DisposePackageVersions' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
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:versions:DisposePackageVersions' :: DisposePackageVersions -> [Text]
$sel:package:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:format:DisposePackageVersions' :: DisposePackageVersions -> PackageFormat
$sel:repository:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:domain:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:versionRevisions:DisposePackageVersions' :: DisposePackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:DisposePackageVersions' :: DisposePackageVersions -> Maybe Text
$sel:expectedStatus:DisposePackageVersions' :: DisposePackageVersions -> Maybe PackageVersionStatus
$sel:domainOwner:DisposePackageVersions' :: DisposePackageVersions -> 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)
          ]
      )

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

instance Data.ToQuery DisposePackageVersions where
  toQuery :: DisposePackageVersions -> QueryString
toQuery DisposePackageVersions' {[Text]
Maybe Text
Maybe (HashMap Text Text)
Maybe PackageVersionStatus
Text
PackageFormat
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:versions:DisposePackageVersions' :: DisposePackageVersions -> [Text]
$sel:package:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:format:DisposePackageVersions' :: DisposePackageVersions -> PackageFormat
$sel:repository:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:domain:DisposePackageVersions' :: DisposePackageVersions -> Text
$sel:versionRevisions:DisposePackageVersions' :: DisposePackageVersions -> Maybe (HashMap Text Text)
$sel:namespace:DisposePackageVersions' :: DisposePackageVersions -> Maybe Text
$sel:expectedStatus:DisposePackageVersions' :: DisposePackageVersions -> Maybe PackageVersionStatus
$sel:domainOwner:DisposePackageVersions' :: DisposePackageVersions -> 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:/ 'newDisposePackageVersionsResponse' smart constructor.
data DisposePackageVersionsResponse = DisposePackageVersionsResponse'
  { -- | A @PackageVersionError@ object that contains a map of errors codes for
    -- the disposed package versions that failed. The possible error codes are:
    --
    -- -   @ALREADY_EXISTS@
    --
    -- -   @MISMATCHED_REVISION@
    --
    -- -   @MISMATCHED_STATUS@
    --
    -- -   @NOT_ALLOWED@
    --
    -- -   @NOT_FOUND@
    --
    -- -   @SKIPPED@
    DisposePackageVersionsResponse
-> Maybe (HashMap Text PackageVersionError)
failedVersions :: Prelude.Maybe (Prelude.HashMap Prelude.Text PackageVersionError),
    -- | A list of the package versions that were successfully disposed.
    DisposePackageVersionsResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions :: Prelude.Maybe (Prelude.HashMap Prelude.Text SuccessfulPackageVersionInfo),
    -- | The response's http status code.
    DisposePackageVersionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DisposePackageVersionsResponse
-> DisposePackageVersionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisposePackageVersionsResponse
-> DisposePackageVersionsResponse -> Bool
$c/= :: DisposePackageVersionsResponse
-> DisposePackageVersionsResponse -> Bool
== :: DisposePackageVersionsResponse
-> DisposePackageVersionsResponse -> Bool
$c== :: DisposePackageVersionsResponse
-> DisposePackageVersionsResponse -> Bool
Prelude.Eq, ReadPrec [DisposePackageVersionsResponse]
ReadPrec DisposePackageVersionsResponse
Int -> ReadS DisposePackageVersionsResponse
ReadS [DisposePackageVersionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DisposePackageVersionsResponse]
$creadListPrec :: ReadPrec [DisposePackageVersionsResponse]
readPrec :: ReadPrec DisposePackageVersionsResponse
$creadPrec :: ReadPrec DisposePackageVersionsResponse
readList :: ReadS [DisposePackageVersionsResponse]
$creadList :: ReadS [DisposePackageVersionsResponse]
readsPrec :: Int -> ReadS DisposePackageVersionsResponse
$creadsPrec :: Int -> ReadS DisposePackageVersionsResponse
Prelude.Read, Int -> DisposePackageVersionsResponse -> ShowS
[DisposePackageVersionsResponse] -> ShowS
DisposePackageVersionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DisposePackageVersionsResponse] -> ShowS
$cshowList :: [DisposePackageVersionsResponse] -> ShowS
show :: DisposePackageVersionsResponse -> String
$cshow :: DisposePackageVersionsResponse -> String
showsPrec :: Int -> DisposePackageVersionsResponse -> ShowS
$cshowsPrec :: Int -> DisposePackageVersionsResponse -> ShowS
Prelude.Show, forall x.
Rep DisposePackageVersionsResponse x
-> DisposePackageVersionsResponse
forall x.
DisposePackageVersionsResponse
-> Rep DisposePackageVersionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DisposePackageVersionsResponse x
-> DisposePackageVersionsResponse
$cfrom :: forall x.
DisposePackageVersionsResponse
-> Rep DisposePackageVersionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'DisposePackageVersionsResponse' 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', 'disposePackageVersionsResponse_failedVersions' - A @PackageVersionError@ object that contains a map of errors codes for
-- the disposed package versions that failed. The possible error codes are:
--
-- -   @ALREADY_EXISTS@
--
-- -   @MISMATCHED_REVISION@
--
-- -   @MISMATCHED_STATUS@
--
-- -   @NOT_ALLOWED@
--
-- -   @NOT_FOUND@
--
-- -   @SKIPPED@
--
-- 'successfulVersions', 'disposePackageVersionsResponse_successfulVersions' - A list of the package versions that were successfully disposed.
--
-- 'httpStatus', 'disposePackageVersionsResponse_httpStatus' - The response's http status code.
newDisposePackageVersionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DisposePackageVersionsResponse
newDisposePackageVersionsResponse :: Int -> DisposePackageVersionsResponse
newDisposePackageVersionsResponse Int
pHttpStatus_ =
  DisposePackageVersionsResponse'
    { $sel:failedVersions:DisposePackageVersionsResponse' :: Maybe (HashMap Text PackageVersionError)
failedVersions =
        forall a. Maybe a
Prelude.Nothing,
      $sel:successfulVersions:DisposePackageVersionsResponse' :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DisposePackageVersionsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A @PackageVersionError@ object that contains a map of errors codes for
-- the disposed package versions that failed. The possible error codes are:
--
-- -   @ALREADY_EXISTS@
--
-- -   @MISMATCHED_REVISION@
--
-- -   @MISMATCHED_STATUS@
--
-- -   @NOT_ALLOWED@
--
-- -   @NOT_FOUND@
--
-- -   @SKIPPED@
disposePackageVersionsResponse_failedVersions :: Lens.Lens' DisposePackageVersionsResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text PackageVersionError))
disposePackageVersionsResponse_failedVersions :: Lens'
  DisposePackageVersionsResponse
  (Maybe (HashMap Text PackageVersionError))
disposePackageVersionsResponse_failedVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersionsResponse' {Maybe (HashMap Text PackageVersionError)
failedVersions :: Maybe (HashMap Text PackageVersionError)
$sel:failedVersions:DisposePackageVersionsResponse' :: DisposePackageVersionsResponse
-> Maybe (HashMap Text PackageVersionError)
failedVersions} -> Maybe (HashMap Text PackageVersionError)
failedVersions) (\s :: DisposePackageVersionsResponse
s@DisposePackageVersionsResponse' {} Maybe (HashMap Text PackageVersionError)
a -> DisposePackageVersionsResponse
s {$sel:failedVersions:DisposePackageVersionsResponse' :: Maybe (HashMap Text PackageVersionError)
failedVersions = Maybe (HashMap Text PackageVersionError)
a} :: DisposePackageVersionsResponse) 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 disposed.
disposePackageVersionsResponse_successfulVersions :: Lens.Lens' DisposePackageVersionsResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text SuccessfulPackageVersionInfo))
disposePackageVersionsResponse_successfulVersions :: Lens'
  DisposePackageVersionsResponse
  (Maybe (HashMap Text SuccessfulPackageVersionInfo))
disposePackageVersionsResponse_successfulVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersionsResponse' {Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
$sel:successfulVersions:DisposePackageVersionsResponse' :: DisposePackageVersionsResponse
-> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions} -> Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions) (\s :: DisposePackageVersionsResponse
s@DisposePackageVersionsResponse' {} Maybe (HashMap Text SuccessfulPackageVersionInfo)
a -> DisposePackageVersionsResponse
s {$sel:successfulVersions:DisposePackageVersionsResponse' :: Maybe (HashMap Text SuccessfulPackageVersionInfo)
successfulVersions = Maybe (HashMap Text SuccessfulPackageVersionInfo)
a} :: DisposePackageVersionsResponse) 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.
disposePackageVersionsResponse_httpStatus :: Lens.Lens' DisposePackageVersionsResponse Prelude.Int
disposePackageVersionsResponse_httpStatus :: Lens' DisposePackageVersionsResponse Int
disposePackageVersionsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisposePackageVersionsResponse' {Int
httpStatus :: Int
$sel:httpStatus:DisposePackageVersionsResponse' :: DisposePackageVersionsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: DisposePackageVersionsResponse
s@DisposePackageVersionsResponse' {} Int
a -> DisposePackageVersionsResponse
s {$sel:httpStatus:DisposePackageVersionsResponse' :: Int
httpStatus = Int
a} :: DisposePackageVersionsResponse)

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