{-# 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.ListPackageVersionDependencies
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns the direct dependencies for a package version. The dependencies
-- are returned as
-- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageDependency.html PackageDependency>
-- objects. CodeArtifact extracts the dependencies for a package version
-- from the metadata file for the package format (for example, the
-- @package.json@ file for npm packages and the @pom.xml@ file for Maven).
-- Any package version dependencies that are not listed in the
-- configuration file are not returned.
module Amazonka.CodeArtifact.ListPackageVersionDependencies
  ( -- * Creating a Request
    ListPackageVersionDependencies (..),
    newListPackageVersionDependencies,

    -- * Request Lenses
    listPackageVersionDependencies_domainOwner,
    listPackageVersionDependencies_namespace,
    listPackageVersionDependencies_nextToken,
    listPackageVersionDependencies_domain,
    listPackageVersionDependencies_repository,
    listPackageVersionDependencies_format,
    listPackageVersionDependencies_package,
    listPackageVersionDependencies_packageVersion,

    -- * Destructuring the Response
    ListPackageVersionDependenciesResponse (..),
    newListPackageVersionDependenciesResponse,

    -- * Response Lenses
    listPackageVersionDependenciesResponse_dependencies,
    listPackageVersionDependenciesResponse_format,
    listPackageVersionDependenciesResponse_namespace,
    listPackageVersionDependenciesResponse_nextToken,
    listPackageVersionDependenciesResponse_package,
    listPackageVersionDependenciesResponse_version,
    listPackageVersionDependenciesResponse_versionRevision,
    listPackageVersionDependenciesResponse_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:/ 'newListPackageVersionDependencies' smart constructor.
data ListPackageVersionDependencies = ListPackageVersionDependencies'
  { -- | The 12-digit account number of the Amazon Web Services account that owns
    -- the domain. It does not include dashes or spaces.
    ListPackageVersionDependencies -> Maybe Text
domainOwner :: Prelude.Maybe Prelude.Text,
    -- | The namespace of the package version with the requested dependencies.
    -- 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.
    ListPackageVersionDependencies -> Maybe Text
namespace :: Prelude.Maybe Prelude.Text,
    -- | The token for the next set of results. Use the value returned in the
    -- previous response in the next request to retrieve the next set of
    -- results.
    ListPackageVersionDependencies -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The name of the domain that contains the repository that contains the
    -- requested package version dependencies.
    ListPackageVersionDependencies -> Text
domain :: Prelude.Text,
    -- | The name of the repository that contains the requested package version.
    ListPackageVersionDependencies -> Text
repository :: Prelude.Text,
    -- | The format of the package with the requested dependencies.
    ListPackageVersionDependencies -> PackageFormat
format :: PackageFormat,
    -- | The name of the package versions\' package.
    ListPackageVersionDependencies -> Text
package :: Prelude.Text,
    -- | A string that contains the package version (for example, @3.5.2@).
    ListPackageVersionDependencies -> Text
packageVersion :: Prelude.Text
  }
  deriving (ListPackageVersionDependencies
-> ListPackageVersionDependencies -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListPackageVersionDependencies
-> ListPackageVersionDependencies -> Bool
$c/= :: ListPackageVersionDependencies
-> ListPackageVersionDependencies -> Bool
== :: ListPackageVersionDependencies
-> ListPackageVersionDependencies -> Bool
$c== :: ListPackageVersionDependencies
-> ListPackageVersionDependencies -> Bool
Prelude.Eq, ReadPrec [ListPackageVersionDependencies]
ReadPrec ListPackageVersionDependencies
Int -> ReadS ListPackageVersionDependencies
ReadS [ListPackageVersionDependencies]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListPackageVersionDependencies]
$creadListPrec :: ReadPrec [ListPackageVersionDependencies]
readPrec :: ReadPrec ListPackageVersionDependencies
$creadPrec :: ReadPrec ListPackageVersionDependencies
readList :: ReadS [ListPackageVersionDependencies]
$creadList :: ReadS [ListPackageVersionDependencies]
readsPrec :: Int -> ReadS ListPackageVersionDependencies
$creadsPrec :: Int -> ReadS ListPackageVersionDependencies
Prelude.Read, Int -> ListPackageVersionDependencies -> ShowS
[ListPackageVersionDependencies] -> ShowS
ListPackageVersionDependencies -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListPackageVersionDependencies] -> ShowS
$cshowList :: [ListPackageVersionDependencies] -> ShowS
show :: ListPackageVersionDependencies -> String
$cshow :: ListPackageVersionDependencies -> String
showsPrec :: Int -> ListPackageVersionDependencies -> ShowS
$cshowsPrec :: Int -> ListPackageVersionDependencies -> ShowS
Prelude.Show, forall x.
Rep ListPackageVersionDependencies x
-> ListPackageVersionDependencies
forall x.
ListPackageVersionDependencies
-> Rep ListPackageVersionDependencies x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListPackageVersionDependencies x
-> ListPackageVersionDependencies
$cfrom :: forall x.
ListPackageVersionDependencies
-> Rep ListPackageVersionDependencies x
Prelude.Generic)

-- |
-- Create a value of 'ListPackageVersionDependencies' 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', 'listPackageVersionDependencies_domainOwner' - The 12-digit account number of the Amazon Web Services account that owns
-- the domain. It does not include dashes or spaces.
--
-- 'namespace', 'listPackageVersionDependencies_namespace' - The namespace of the package version with the requested dependencies.
-- 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.
--
-- 'nextToken', 'listPackageVersionDependencies_nextToken' - The token for the next set of results. Use the value returned in the
-- previous response in the next request to retrieve the next set of
-- results.
--
-- 'domain', 'listPackageVersionDependencies_domain' - The name of the domain that contains the repository that contains the
-- requested package version dependencies.
--
-- 'repository', 'listPackageVersionDependencies_repository' - The name of the repository that contains the requested package version.
--
-- 'format', 'listPackageVersionDependencies_format' - The format of the package with the requested dependencies.
--
-- 'package', 'listPackageVersionDependencies_package' - The name of the package versions\' package.
--
-- 'packageVersion', 'listPackageVersionDependencies_packageVersion' - A string that contains the package version (for example, @3.5.2@).
newListPackageVersionDependencies ::
  -- | 'domain'
  Prelude.Text ->
  -- | 'repository'
  Prelude.Text ->
  -- | 'format'
  PackageFormat ->
  -- | 'package'
  Prelude.Text ->
  -- | 'packageVersion'
  Prelude.Text ->
  ListPackageVersionDependencies
newListPackageVersionDependencies :: Text
-> Text
-> PackageFormat
-> Text
-> Text
-> ListPackageVersionDependencies
newListPackageVersionDependencies
  Text
pDomain_
  Text
pRepository_
  PackageFormat
pFormat_
  Text
pPackage_
  Text
pPackageVersion_ =
    ListPackageVersionDependencies'
      { $sel:domainOwner:ListPackageVersionDependencies' :: Maybe Text
domainOwner =
          forall a. Maybe a
Prelude.Nothing,
        $sel:namespace:ListPackageVersionDependencies' :: Maybe Text
namespace = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListPackageVersionDependencies' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:domain:ListPackageVersionDependencies' :: Text
domain = Text
pDomain_,
        $sel:repository:ListPackageVersionDependencies' :: Text
repository = Text
pRepository_,
        $sel:format:ListPackageVersionDependencies' :: PackageFormat
format = PackageFormat
pFormat_,
        $sel:package:ListPackageVersionDependencies' :: Text
package = Text
pPackage_,
        $sel:packageVersion:ListPackageVersionDependencies' :: Text
packageVersion = Text
pPackageVersion_
      }

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

-- | The namespace of the package version with the requested dependencies.
-- 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.
listPackageVersionDependencies_namespace :: Lens.Lens' ListPackageVersionDependencies (Prelude.Maybe Prelude.Text)
listPackageVersionDependencies_namespace :: Lens' ListPackageVersionDependencies (Maybe Text)
listPackageVersionDependencies_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependencies' {Maybe Text
namespace :: Maybe Text
$sel:namespace:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
namespace} -> Maybe Text
namespace) (\s :: ListPackageVersionDependencies
s@ListPackageVersionDependencies' {} Maybe Text
a -> ListPackageVersionDependencies
s {$sel:namespace:ListPackageVersionDependencies' :: Maybe Text
namespace = Maybe Text
a} :: ListPackageVersionDependencies)

-- | The token for the next set of results. Use the value returned in the
-- previous response in the next request to retrieve the next set of
-- results.
listPackageVersionDependencies_nextToken :: Lens.Lens' ListPackageVersionDependencies (Prelude.Maybe Prelude.Text)
listPackageVersionDependencies_nextToken :: Lens' ListPackageVersionDependencies (Maybe Text)
listPackageVersionDependencies_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependencies' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListPackageVersionDependencies
s@ListPackageVersionDependencies' {} Maybe Text
a -> ListPackageVersionDependencies
s {$sel:nextToken:ListPackageVersionDependencies' :: Maybe Text
nextToken = Maybe Text
a} :: ListPackageVersionDependencies)

-- | The name of the domain that contains the repository that contains the
-- requested package version dependencies.
listPackageVersionDependencies_domain :: Lens.Lens' ListPackageVersionDependencies Prelude.Text
listPackageVersionDependencies_domain :: Lens' ListPackageVersionDependencies Text
listPackageVersionDependencies_domain = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependencies' {Text
domain :: Text
$sel:domain:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
domain} -> Text
domain) (\s :: ListPackageVersionDependencies
s@ListPackageVersionDependencies' {} Text
a -> ListPackageVersionDependencies
s {$sel:domain:ListPackageVersionDependencies' :: Text
domain = Text
a} :: ListPackageVersionDependencies)

-- | The name of the repository that contains the requested package version.
listPackageVersionDependencies_repository :: Lens.Lens' ListPackageVersionDependencies Prelude.Text
listPackageVersionDependencies_repository :: Lens' ListPackageVersionDependencies Text
listPackageVersionDependencies_repository = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependencies' {Text
repository :: Text
$sel:repository:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
repository} -> Text
repository) (\s :: ListPackageVersionDependencies
s@ListPackageVersionDependencies' {} Text
a -> ListPackageVersionDependencies
s {$sel:repository:ListPackageVersionDependencies' :: Text
repository = Text
a} :: ListPackageVersionDependencies)

-- | The format of the package with the requested dependencies.
listPackageVersionDependencies_format :: Lens.Lens' ListPackageVersionDependencies PackageFormat
listPackageVersionDependencies_format :: Lens' ListPackageVersionDependencies PackageFormat
listPackageVersionDependencies_format = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependencies' {PackageFormat
format :: PackageFormat
$sel:format:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> PackageFormat
format} -> PackageFormat
format) (\s :: ListPackageVersionDependencies
s@ListPackageVersionDependencies' {} PackageFormat
a -> ListPackageVersionDependencies
s {$sel:format:ListPackageVersionDependencies' :: PackageFormat
format = PackageFormat
a} :: ListPackageVersionDependencies)

-- | The name of the package versions\' package.
listPackageVersionDependencies_package :: Lens.Lens' ListPackageVersionDependencies Prelude.Text
listPackageVersionDependencies_package :: Lens' ListPackageVersionDependencies Text
listPackageVersionDependencies_package = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependencies' {Text
package :: Text
$sel:package:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
package} -> Text
package) (\s :: ListPackageVersionDependencies
s@ListPackageVersionDependencies' {} Text
a -> ListPackageVersionDependencies
s {$sel:package:ListPackageVersionDependencies' :: Text
package = Text
a} :: ListPackageVersionDependencies)

-- | A string that contains the package version (for example, @3.5.2@).
listPackageVersionDependencies_packageVersion :: Lens.Lens' ListPackageVersionDependencies Prelude.Text
listPackageVersionDependencies_packageVersion :: Lens' ListPackageVersionDependencies Text
listPackageVersionDependencies_packageVersion = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependencies' {Text
packageVersion :: Text
$sel:packageVersion:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
packageVersion} -> Text
packageVersion) (\s :: ListPackageVersionDependencies
s@ListPackageVersionDependencies' {} Text
a -> ListPackageVersionDependencies
s {$sel:packageVersion:ListPackageVersionDependencies' :: Text
packageVersion = Text
a} :: ListPackageVersionDependencies)

instance
  Core.AWSRequest
    ListPackageVersionDependencies
  where
  type
    AWSResponse ListPackageVersionDependencies =
      ListPackageVersionDependenciesResponse
  request :: (Service -> Service)
-> ListPackageVersionDependencies
-> Request ListPackageVersionDependencies
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 ListPackageVersionDependencies
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse ListPackageVersionDependencies)))
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 [PackageDependency]
-> Maybe PackageFormat
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Int
-> ListPackageVersionDependenciesResponse
ListPackageVersionDependenciesResponse'
            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
"dependencies" 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
"format")
            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
"namespace")
            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
"nextToken")
            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
"package")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"version")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"versionRevision")
            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
    ListPackageVersionDependencies
  where
  hashWithSalt :: Int -> ListPackageVersionDependencies -> Int
hashWithSalt
    Int
_salt
    ListPackageVersionDependencies' {Maybe Text
Text
PackageFormat
packageVersion :: Text
package :: Text
format :: PackageFormat
repository :: Text
domain :: Text
nextToken :: Maybe Text
namespace :: Maybe Text
domainOwner :: Maybe Text
$sel:packageVersion:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:package:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:format:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> PackageFormat
$sel:repository:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:domain:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:nextToken:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
$sel:namespace:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
$sel:domainOwner:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> 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 Text
namespace
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
        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
packageVersion

instance
  Prelude.NFData
    ListPackageVersionDependencies
  where
  rnf :: ListPackageVersionDependencies -> ()
rnf ListPackageVersionDependencies' {Maybe Text
Text
PackageFormat
packageVersion :: Text
package :: Text
format :: PackageFormat
repository :: Text
domain :: Text
nextToken :: Maybe Text
namespace :: Maybe Text
domainOwner :: Maybe Text
$sel:packageVersion:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:package:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:format:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> PackageFormat
$sel:repository:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:domain:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:nextToken:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
$sel:namespace:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
$sel:domainOwner:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> 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 Text
namespace
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      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
packageVersion

instance
  Data.ToHeaders
    ListPackageVersionDependencies
  where
  toHeaders :: ListPackageVersionDependencies -> 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 ListPackageVersionDependencies where
  toJSON :: ListPackageVersionDependencies -> Value
toJSON = forall a b. a -> b -> a
Prelude.const (Object -> Value
Data.Object forall a. Monoid a => a
Prelude.mempty)

instance Data.ToPath ListPackageVersionDependencies where
  toPath :: ListPackageVersionDependencies -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const ByteString
"/v1/package/version/dependencies"

instance Data.ToQuery ListPackageVersionDependencies where
  toQuery :: ListPackageVersionDependencies -> QueryString
toQuery ListPackageVersionDependencies' {Maybe Text
Text
PackageFormat
packageVersion :: Text
package :: Text
format :: PackageFormat
repository :: Text
domain :: Text
nextToken :: Maybe Text
namespace :: Maybe Text
domainOwner :: Maybe Text
$sel:packageVersion:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:package:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:format:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> PackageFormat
$sel:repository:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:domain:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Text
$sel:nextToken:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
$sel:namespace:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> Maybe Text
$sel:domainOwner:ListPackageVersionDependencies' :: ListPackageVersionDependencies -> 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
"next-token" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        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,
        ByteString
"version" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
packageVersion
      ]

-- | /See:/ 'newListPackageVersionDependenciesResponse' smart constructor.
data ListPackageVersionDependenciesResponse = ListPackageVersionDependenciesResponse'
  { -- | The returned list of
    -- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageDependency.html PackageDependency>
    -- objects.
    ListPackageVersionDependenciesResponse -> Maybe [PackageDependency]
dependencies :: Prelude.Maybe [PackageDependency],
    -- | A format that specifies the type of the package that contains the
    -- returned dependencies.
    ListPackageVersionDependenciesResponse -> Maybe PackageFormat
format :: Prelude.Maybe PackageFormat,
    -- | The namespace of the package version that contains the returned
    -- dependencies. 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.
    ListPackageVersionDependenciesResponse -> Maybe Text
namespace :: Prelude.Maybe Prelude.Text,
    -- | The token for the next set of results. Use the value returned in the
    -- previous response in the next request to retrieve the next set of
    -- results.
    ListPackageVersionDependenciesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The name of the package that contains the returned package versions
    -- dependencies.
    ListPackageVersionDependenciesResponse -> Maybe Text
package :: Prelude.Maybe Prelude.Text,
    -- | The version of the package that is specified in the request.
    ListPackageVersionDependenciesResponse -> Maybe Text
version :: Prelude.Maybe Prelude.Text,
    -- | The current revision associated with the package version.
    ListPackageVersionDependenciesResponse -> Maybe Text
versionRevision :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListPackageVersionDependenciesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListPackageVersionDependenciesResponse
-> ListPackageVersionDependenciesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListPackageVersionDependenciesResponse
-> ListPackageVersionDependenciesResponse -> Bool
$c/= :: ListPackageVersionDependenciesResponse
-> ListPackageVersionDependenciesResponse -> Bool
== :: ListPackageVersionDependenciesResponse
-> ListPackageVersionDependenciesResponse -> Bool
$c== :: ListPackageVersionDependenciesResponse
-> ListPackageVersionDependenciesResponse -> Bool
Prelude.Eq, ReadPrec [ListPackageVersionDependenciesResponse]
ReadPrec ListPackageVersionDependenciesResponse
Int -> ReadS ListPackageVersionDependenciesResponse
ReadS [ListPackageVersionDependenciesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListPackageVersionDependenciesResponse]
$creadListPrec :: ReadPrec [ListPackageVersionDependenciesResponse]
readPrec :: ReadPrec ListPackageVersionDependenciesResponse
$creadPrec :: ReadPrec ListPackageVersionDependenciesResponse
readList :: ReadS [ListPackageVersionDependenciesResponse]
$creadList :: ReadS [ListPackageVersionDependenciesResponse]
readsPrec :: Int -> ReadS ListPackageVersionDependenciesResponse
$creadsPrec :: Int -> ReadS ListPackageVersionDependenciesResponse
Prelude.Read, Int -> ListPackageVersionDependenciesResponse -> ShowS
[ListPackageVersionDependenciesResponse] -> ShowS
ListPackageVersionDependenciesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListPackageVersionDependenciesResponse] -> ShowS
$cshowList :: [ListPackageVersionDependenciesResponse] -> ShowS
show :: ListPackageVersionDependenciesResponse -> String
$cshow :: ListPackageVersionDependenciesResponse -> String
showsPrec :: Int -> ListPackageVersionDependenciesResponse -> ShowS
$cshowsPrec :: Int -> ListPackageVersionDependenciesResponse -> ShowS
Prelude.Show, forall x.
Rep ListPackageVersionDependenciesResponse x
-> ListPackageVersionDependenciesResponse
forall x.
ListPackageVersionDependenciesResponse
-> Rep ListPackageVersionDependenciesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListPackageVersionDependenciesResponse x
-> ListPackageVersionDependenciesResponse
$cfrom :: forall x.
ListPackageVersionDependenciesResponse
-> Rep ListPackageVersionDependenciesResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListPackageVersionDependenciesResponse' 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:
--
-- 'dependencies', 'listPackageVersionDependenciesResponse_dependencies' - The returned list of
-- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageDependency.html PackageDependency>
-- objects.
--
-- 'format', 'listPackageVersionDependenciesResponse_format' - A format that specifies the type of the package that contains the
-- returned dependencies.
--
-- 'namespace', 'listPackageVersionDependenciesResponse_namespace' - The namespace of the package version that contains the returned
-- dependencies. 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.
--
-- 'nextToken', 'listPackageVersionDependenciesResponse_nextToken' - The token for the next set of results. Use the value returned in the
-- previous response in the next request to retrieve the next set of
-- results.
--
-- 'package', 'listPackageVersionDependenciesResponse_package' - The name of the package that contains the returned package versions
-- dependencies.
--
-- 'version', 'listPackageVersionDependenciesResponse_version' - The version of the package that is specified in the request.
--
-- 'versionRevision', 'listPackageVersionDependenciesResponse_versionRevision' - The current revision associated with the package version.
--
-- 'httpStatus', 'listPackageVersionDependenciesResponse_httpStatus' - The response's http status code.
newListPackageVersionDependenciesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListPackageVersionDependenciesResponse
newListPackageVersionDependenciesResponse :: Int -> ListPackageVersionDependenciesResponse
newListPackageVersionDependenciesResponse
  Int
pHttpStatus_ =
    ListPackageVersionDependenciesResponse'
      { $sel:dependencies:ListPackageVersionDependenciesResponse' :: Maybe [PackageDependency]
dependencies =
          forall a. Maybe a
Prelude.Nothing,
        $sel:format:ListPackageVersionDependenciesResponse' :: Maybe PackageFormat
format = forall a. Maybe a
Prelude.Nothing,
        $sel:namespace:ListPackageVersionDependenciesResponse' :: Maybe Text
namespace = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListPackageVersionDependenciesResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:package:ListPackageVersionDependenciesResponse' :: Maybe Text
package = forall a. Maybe a
Prelude.Nothing,
        $sel:version:ListPackageVersionDependenciesResponse' :: Maybe Text
version = forall a. Maybe a
Prelude.Nothing,
        $sel:versionRevision:ListPackageVersionDependenciesResponse' :: Maybe Text
versionRevision = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:ListPackageVersionDependenciesResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | The returned list of
-- <https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_PackageDependency.html PackageDependency>
-- objects.
listPackageVersionDependenciesResponse_dependencies :: Lens.Lens' ListPackageVersionDependenciesResponse (Prelude.Maybe [PackageDependency])
listPackageVersionDependenciesResponse_dependencies :: Lens'
  ListPackageVersionDependenciesResponse (Maybe [PackageDependency])
listPackageVersionDependenciesResponse_dependencies = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependenciesResponse' {Maybe [PackageDependency]
dependencies :: Maybe [PackageDependency]
$sel:dependencies:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe [PackageDependency]
dependencies} -> Maybe [PackageDependency]
dependencies) (\s :: ListPackageVersionDependenciesResponse
s@ListPackageVersionDependenciesResponse' {} Maybe [PackageDependency]
a -> ListPackageVersionDependenciesResponse
s {$sel:dependencies:ListPackageVersionDependenciesResponse' :: Maybe [PackageDependency]
dependencies = Maybe [PackageDependency]
a} :: ListPackageVersionDependenciesResponse) 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 format that specifies the type of the package that contains the
-- returned dependencies.
listPackageVersionDependenciesResponse_format :: Lens.Lens' ListPackageVersionDependenciesResponse (Prelude.Maybe PackageFormat)
listPackageVersionDependenciesResponse_format :: Lens' ListPackageVersionDependenciesResponse (Maybe PackageFormat)
listPackageVersionDependenciesResponse_format = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependenciesResponse' {Maybe PackageFormat
format :: Maybe PackageFormat
$sel:format:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe PackageFormat
format} -> Maybe PackageFormat
format) (\s :: ListPackageVersionDependenciesResponse
s@ListPackageVersionDependenciesResponse' {} Maybe PackageFormat
a -> ListPackageVersionDependenciesResponse
s {$sel:format:ListPackageVersionDependenciesResponse' :: Maybe PackageFormat
format = Maybe PackageFormat
a} :: ListPackageVersionDependenciesResponse)

-- | The namespace of the package version that contains the returned
-- dependencies. 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.
listPackageVersionDependenciesResponse_namespace :: Lens.Lens' ListPackageVersionDependenciesResponse (Prelude.Maybe Prelude.Text)
listPackageVersionDependenciesResponse_namespace :: Lens' ListPackageVersionDependenciesResponse (Maybe Text)
listPackageVersionDependenciesResponse_namespace = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependenciesResponse' {Maybe Text
namespace :: Maybe Text
$sel:namespace:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
namespace} -> Maybe Text
namespace) (\s :: ListPackageVersionDependenciesResponse
s@ListPackageVersionDependenciesResponse' {} Maybe Text
a -> ListPackageVersionDependenciesResponse
s {$sel:namespace:ListPackageVersionDependenciesResponse' :: Maybe Text
namespace = Maybe Text
a} :: ListPackageVersionDependenciesResponse)

-- | The token for the next set of results. Use the value returned in the
-- previous response in the next request to retrieve the next set of
-- results.
listPackageVersionDependenciesResponse_nextToken :: Lens.Lens' ListPackageVersionDependenciesResponse (Prelude.Maybe Prelude.Text)
listPackageVersionDependenciesResponse_nextToken :: Lens' ListPackageVersionDependenciesResponse (Maybe Text)
listPackageVersionDependenciesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependenciesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListPackageVersionDependenciesResponse
s@ListPackageVersionDependenciesResponse' {} Maybe Text
a -> ListPackageVersionDependenciesResponse
s {$sel:nextToken:ListPackageVersionDependenciesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListPackageVersionDependenciesResponse)

-- | The name of the package that contains the returned package versions
-- dependencies.
listPackageVersionDependenciesResponse_package :: Lens.Lens' ListPackageVersionDependenciesResponse (Prelude.Maybe Prelude.Text)
listPackageVersionDependenciesResponse_package :: Lens' ListPackageVersionDependenciesResponse (Maybe Text)
listPackageVersionDependenciesResponse_package = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependenciesResponse' {Maybe Text
package :: Maybe Text
$sel:package:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
package} -> Maybe Text
package) (\s :: ListPackageVersionDependenciesResponse
s@ListPackageVersionDependenciesResponse' {} Maybe Text
a -> ListPackageVersionDependenciesResponse
s {$sel:package:ListPackageVersionDependenciesResponse' :: Maybe Text
package = Maybe Text
a} :: ListPackageVersionDependenciesResponse)

-- | The version of the package that is specified in the request.
listPackageVersionDependenciesResponse_version :: Lens.Lens' ListPackageVersionDependenciesResponse (Prelude.Maybe Prelude.Text)
listPackageVersionDependenciesResponse_version :: Lens' ListPackageVersionDependenciesResponse (Maybe Text)
listPackageVersionDependenciesResponse_version = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependenciesResponse' {Maybe Text
version :: Maybe Text
$sel:version:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
version} -> Maybe Text
version) (\s :: ListPackageVersionDependenciesResponse
s@ListPackageVersionDependenciesResponse' {} Maybe Text
a -> ListPackageVersionDependenciesResponse
s {$sel:version:ListPackageVersionDependenciesResponse' :: Maybe Text
version = Maybe Text
a} :: ListPackageVersionDependenciesResponse)

-- | The current revision associated with the package version.
listPackageVersionDependenciesResponse_versionRevision :: Lens.Lens' ListPackageVersionDependenciesResponse (Prelude.Maybe Prelude.Text)
listPackageVersionDependenciesResponse_versionRevision :: Lens' ListPackageVersionDependenciesResponse (Maybe Text)
listPackageVersionDependenciesResponse_versionRevision = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListPackageVersionDependenciesResponse' {Maybe Text
versionRevision :: Maybe Text
$sel:versionRevision:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
versionRevision} -> Maybe Text
versionRevision) (\s :: ListPackageVersionDependenciesResponse
s@ListPackageVersionDependenciesResponse' {} Maybe Text
a -> ListPackageVersionDependenciesResponse
s {$sel:versionRevision:ListPackageVersionDependenciesResponse' :: Maybe Text
versionRevision = Maybe Text
a} :: ListPackageVersionDependenciesResponse)

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

instance
  Prelude.NFData
    ListPackageVersionDependenciesResponse
  where
  rnf :: ListPackageVersionDependenciesResponse -> ()
rnf ListPackageVersionDependenciesResponse' {Int
Maybe [PackageDependency]
Maybe Text
Maybe PackageFormat
httpStatus :: Int
versionRevision :: Maybe Text
version :: Maybe Text
package :: Maybe Text
nextToken :: Maybe Text
namespace :: Maybe Text
format :: Maybe PackageFormat
dependencies :: Maybe [PackageDependency]
$sel:httpStatus:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Int
$sel:versionRevision:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
$sel:version:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
$sel:package:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
$sel:nextToken:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
$sel:namespace:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe Text
$sel:format:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe PackageFormat
$sel:dependencies:ListPackageVersionDependenciesResponse' :: ListPackageVersionDependenciesResponse -> Maybe [PackageDependency]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [PackageDependency]
dependencies
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PackageFormat
format
      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 Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
package
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
version
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
versionRevision
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus