{-# 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.Signer.ListSigningProfiles
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Lists all available signing profiles in your AWS account. Returns only
-- profiles with an @ACTIVE@ status unless the @includeCanceled@ request
-- field is set to @true@. If additional jobs remain to be listed, code
-- signing returns a @nextToken@ value. Use this value in subsequent calls
-- to @ListSigningJobs@ to fetch the remaining values. You can continue
-- calling @ListSigningJobs@ with your @maxResults@ parameter and with new
-- values that code signing returns in the @nextToken@ parameter until all
-- of your signing jobs have been returned.
--
-- This operation returns paginated results.
module Amazonka.Signer.ListSigningProfiles
  ( -- * Creating a Request
    ListSigningProfiles (..),
    newListSigningProfiles,

    -- * Request Lenses
    listSigningProfiles_includeCanceled,
    listSigningProfiles_maxResults,
    listSigningProfiles_nextToken,
    listSigningProfiles_platformId,
    listSigningProfiles_statuses,

    -- * Destructuring the Response
    ListSigningProfilesResponse (..),
    newListSigningProfilesResponse,

    -- * Response Lenses
    listSigningProfilesResponse_nextToken,
    listSigningProfilesResponse_profiles,
    listSigningProfilesResponse_httpStatus,
  )
where

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
import Amazonka.Signer.Types

-- | /See:/ 'newListSigningProfiles' smart constructor.
data ListSigningProfiles = ListSigningProfiles'
  { -- | Designates whether to include profiles with the status of @CANCELED@.
    ListSigningProfiles -> Maybe Bool
includeCanceled :: Prelude.Maybe Prelude.Bool,
    -- | The maximum number of profiles to be returned.
    ListSigningProfiles -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | Value for specifying the next set of paginated results to return. After
    -- you receive a response with truncated results, use this parameter in a
    -- subsequent request. Set it to the value of @nextToken@ from the response
    -- that you just received.
    ListSigningProfiles -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Filters results to return only signing jobs initiated for a specified
    -- signing platform.
    ListSigningProfiles -> Maybe Text
platformId :: Prelude.Maybe Prelude.Text,
    -- | Filters results to return only signing jobs with statuses in the
    -- specified list.
    ListSigningProfiles -> Maybe [SigningProfileStatus]
statuses :: Prelude.Maybe [SigningProfileStatus]
  }
  deriving (ListSigningProfiles -> ListSigningProfiles -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListSigningProfiles -> ListSigningProfiles -> Bool
$c/= :: ListSigningProfiles -> ListSigningProfiles -> Bool
== :: ListSigningProfiles -> ListSigningProfiles -> Bool
$c== :: ListSigningProfiles -> ListSigningProfiles -> Bool
Prelude.Eq, ReadPrec [ListSigningProfiles]
ReadPrec ListSigningProfiles
Int -> ReadS ListSigningProfiles
ReadS [ListSigningProfiles]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListSigningProfiles]
$creadListPrec :: ReadPrec [ListSigningProfiles]
readPrec :: ReadPrec ListSigningProfiles
$creadPrec :: ReadPrec ListSigningProfiles
readList :: ReadS [ListSigningProfiles]
$creadList :: ReadS [ListSigningProfiles]
readsPrec :: Int -> ReadS ListSigningProfiles
$creadsPrec :: Int -> ReadS ListSigningProfiles
Prelude.Read, Int -> ListSigningProfiles -> ShowS
[ListSigningProfiles] -> ShowS
ListSigningProfiles -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListSigningProfiles] -> ShowS
$cshowList :: [ListSigningProfiles] -> ShowS
show :: ListSigningProfiles -> String
$cshow :: ListSigningProfiles -> String
showsPrec :: Int -> ListSigningProfiles -> ShowS
$cshowsPrec :: Int -> ListSigningProfiles -> ShowS
Prelude.Show, forall x. Rep ListSigningProfiles x -> ListSigningProfiles
forall x. ListSigningProfiles -> Rep ListSigningProfiles x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListSigningProfiles x -> ListSigningProfiles
$cfrom :: forall x. ListSigningProfiles -> Rep ListSigningProfiles x
Prelude.Generic)

-- |
-- Create a value of 'ListSigningProfiles' 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:
--
-- 'includeCanceled', 'listSigningProfiles_includeCanceled' - Designates whether to include profiles with the status of @CANCELED@.
--
-- 'maxResults', 'listSigningProfiles_maxResults' - The maximum number of profiles to be returned.
--
-- 'nextToken', 'listSigningProfiles_nextToken' - Value for specifying the next set of paginated results to return. After
-- you receive a response with truncated results, use this parameter in a
-- subsequent request. Set it to the value of @nextToken@ from the response
-- that you just received.
--
-- 'platformId', 'listSigningProfiles_platformId' - Filters results to return only signing jobs initiated for a specified
-- signing platform.
--
-- 'statuses', 'listSigningProfiles_statuses' - Filters results to return only signing jobs with statuses in the
-- specified list.
newListSigningProfiles ::
  ListSigningProfiles
newListSigningProfiles :: ListSigningProfiles
newListSigningProfiles =
  ListSigningProfiles'
    { $sel:includeCanceled:ListSigningProfiles' :: Maybe Bool
includeCanceled =
        forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListSigningProfiles' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListSigningProfiles' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:platformId:ListSigningProfiles' :: Maybe Text
platformId = forall a. Maybe a
Prelude.Nothing,
      $sel:statuses:ListSigningProfiles' :: Maybe [SigningProfileStatus]
statuses = forall a. Maybe a
Prelude.Nothing
    }

-- | Designates whether to include profiles with the status of @CANCELED@.
listSigningProfiles_includeCanceled :: Lens.Lens' ListSigningProfiles (Prelude.Maybe Prelude.Bool)
listSigningProfiles_includeCanceled :: Lens' ListSigningProfiles (Maybe Bool)
listSigningProfiles_includeCanceled = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfiles' {Maybe Bool
includeCanceled :: Maybe Bool
$sel:includeCanceled:ListSigningProfiles' :: ListSigningProfiles -> Maybe Bool
includeCanceled} -> Maybe Bool
includeCanceled) (\s :: ListSigningProfiles
s@ListSigningProfiles' {} Maybe Bool
a -> ListSigningProfiles
s {$sel:includeCanceled:ListSigningProfiles' :: Maybe Bool
includeCanceled = Maybe Bool
a} :: ListSigningProfiles)

-- | The maximum number of profiles to be returned.
listSigningProfiles_maxResults :: Lens.Lens' ListSigningProfiles (Prelude.Maybe Prelude.Natural)
listSigningProfiles_maxResults :: Lens' ListSigningProfiles (Maybe Natural)
listSigningProfiles_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfiles' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListSigningProfiles' :: ListSigningProfiles -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListSigningProfiles
s@ListSigningProfiles' {} Maybe Natural
a -> ListSigningProfiles
s {$sel:maxResults:ListSigningProfiles' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListSigningProfiles)

-- | Value for specifying the next set of paginated results to return. After
-- you receive a response with truncated results, use this parameter in a
-- subsequent request. Set it to the value of @nextToken@ from the response
-- that you just received.
listSigningProfiles_nextToken :: Lens.Lens' ListSigningProfiles (Prelude.Maybe Prelude.Text)
listSigningProfiles_nextToken :: Lens' ListSigningProfiles (Maybe Text)
listSigningProfiles_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfiles' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSigningProfiles
s@ListSigningProfiles' {} Maybe Text
a -> ListSigningProfiles
s {$sel:nextToken:ListSigningProfiles' :: Maybe Text
nextToken = Maybe Text
a} :: ListSigningProfiles)

-- | Filters results to return only signing jobs initiated for a specified
-- signing platform.
listSigningProfiles_platformId :: Lens.Lens' ListSigningProfiles (Prelude.Maybe Prelude.Text)
listSigningProfiles_platformId :: Lens' ListSigningProfiles (Maybe Text)
listSigningProfiles_platformId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfiles' {Maybe Text
platformId :: Maybe Text
$sel:platformId:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
platformId} -> Maybe Text
platformId) (\s :: ListSigningProfiles
s@ListSigningProfiles' {} Maybe Text
a -> ListSigningProfiles
s {$sel:platformId:ListSigningProfiles' :: Maybe Text
platformId = Maybe Text
a} :: ListSigningProfiles)

-- | Filters results to return only signing jobs with statuses in the
-- specified list.
listSigningProfiles_statuses :: Lens.Lens' ListSigningProfiles (Prelude.Maybe [SigningProfileStatus])
listSigningProfiles_statuses :: Lens' ListSigningProfiles (Maybe [SigningProfileStatus])
listSigningProfiles_statuses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfiles' {Maybe [SigningProfileStatus]
statuses :: Maybe [SigningProfileStatus]
$sel:statuses:ListSigningProfiles' :: ListSigningProfiles -> Maybe [SigningProfileStatus]
statuses} -> Maybe [SigningProfileStatus]
statuses) (\s :: ListSigningProfiles
s@ListSigningProfiles' {} Maybe [SigningProfileStatus]
a -> ListSigningProfiles
s {$sel:statuses:ListSigningProfiles' :: Maybe [SigningProfileStatus]
statuses = Maybe [SigningProfileStatus]
a} :: ListSigningProfiles) 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

instance Core.AWSPager ListSigningProfiles where
  page :: ListSigningProfiles
-> AWSResponse ListSigningProfiles -> Maybe ListSigningProfiles
page ListSigningProfiles
rq AWSResponse ListSigningProfiles
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListSigningProfiles
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListSigningProfilesResponse (Maybe Text)
listSigningProfilesResponse_nextToken
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListSigningProfiles
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListSigningProfilesResponse (Maybe [SigningProfile])
listSigningProfilesResponse_profiles
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListSigningProfiles
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListSigningProfiles (Maybe Text)
listSigningProfiles_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListSigningProfiles
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListSigningProfilesResponse (Maybe Text)
listSigningProfilesResponse_nextToken
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest ListSigningProfiles where
  type
    AWSResponse ListSigningProfiles =
      ListSigningProfilesResponse
  request :: (Service -> Service)
-> ListSigningProfiles -> Request ListSigningProfiles
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListSigningProfiles
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListSigningProfiles)))
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 Text
-> Maybe [SigningProfile] -> Int -> ListSigningProfilesResponse
ListSigningProfilesResponse'
            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
"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
"profiles" 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 ListSigningProfiles where
  hashWithSalt :: Int -> ListSigningProfiles -> Int
hashWithSalt Int
_salt ListSigningProfiles' {Maybe Bool
Maybe Natural
Maybe [SigningProfileStatus]
Maybe Text
statuses :: Maybe [SigningProfileStatus]
platformId :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
includeCanceled :: Maybe Bool
$sel:statuses:ListSigningProfiles' :: ListSigningProfiles -> Maybe [SigningProfileStatus]
$sel:platformId:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
$sel:nextToken:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
$sel:maxResults:ListSigningProfiles' :: ListSigningProfiles -> Maybe Natural
$sel:includeCanceled:ListSigningProfiles' :: ListSigningProfiles -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
includeCanceled
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
platformId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [SigningProfileStatus]
statuses

instance Prelude.NFData ListSigningProfiles where
  rnf :: ListSigningProfiles -> ()
rnf ListSigningProfiles' {Maybe Bool
Maybe Natural
Maybe [SigningProfileStatus]
Maybe Text
statuses :: Maybe [SigningProfileStatus]
platformId :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
includeCanceled :: Maybe Bool
$sel:statuses:ListSigningProfiles' :: ListSigningProfiles -> Maybe [SigningProfileStatus]
$sel:platformId:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
$sel:nextToken:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
$sel:maxResults:ListSigningProfiles' :: ListSigningProfiles -> Maybe Natural
$sel:includeCanceled:ListSigningProfiles' :: ListSigningProfiles -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
includeCanceled
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxResults
      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
platformId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [SigningProfileStatus]
statuses

instance Data.ToHeaders ListSigningProfiles where
  toHeaders :: ListSigningProfiles -> 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.ToPath ListSigningProfiles where
  toPath :: ListSigningProfiles -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/signing-profiles"

instance Data.ToQuery ListSigningProfiles where
  toQuery :: ListSigningProfiles -> QueryString
toQuery ListSigningProfiles' {Maybe Bool
Maybe Natural
Maybe [SigningProfileStatus]
Maybe Text
statuses :: Maybe [SigningProfileStatus]
platformId :: Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
includeCanceled :: Maybe Bool
$sel:statuses:ListSigningProfiles' :: ListSigningProfiles -> Maybe [SigningProfileStatus]
$sel:platformId:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
$sel:nextToken:ListSigningProfiles' :: ListSigningProfiles -> Maybe Text
$sel:maxResults:ListSigningProfiles' :: ListSigningProfiles -> Maybe Natural
$sel:includeCanceled:ListSigningProfiles' :: ListSigningProfiles -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"includeCanceled" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
includeCanceled,
        ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        ByteString
"platformId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
platformId,
        ByteString
"statuses"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a. ToQuery a => a -> QueryString
Data.toQuery
            (forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [SigningProfileStatus]
statuses)
      ]

-- | /See:/ 'newListSigningProfilesResponse' smart constructor.
data ListSigningProfilesResponse = ListSigningProfilesResponse'
  { -- | Value for specifying the next set of paginated results to return.
    ListSigningProfilesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A list of profiles that are available in the AWS account. This includes
    -- profiles with the status of @CANCELED@ if the @includeCanceled@
    -- parameter is set to @true@.
    ListSigningProfilesResponse -> Maybe [SigningProfile]
profiles :: Prelude.Maybe [SigningProfile],
    -- | The response's http status code.
    ListSigningProfilesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListSigningProfilesResponse -> ListSigningProfilesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListSigningProfilesResponse -> ListSigningProfilesResponse -> Bool
$c/= :: ListSigningProfilesResponse -> ListSigningProfilesResponse -> Bool
== :: ListSigningProfilesResponse -> ListSigningProfilesResponse -> Bool
$c== :: ListSigningProfilesResponse -> ListSigningProfilesResponse -> Bool
Prelude.Eq, ReadPrec [ListSigningProfilesResponse]
ReadPrec ListSigningProfilesResponse
Int -> ReadS ListSigningProfilesResponse
ReadS [ListSigningProfilesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListSigningProfilesResponse]
$creadListPrec :: ReadPrec [ListSigningProfilesResponse]
readPrec :: ReadPrec ListSigningProfilesResponse
$creadPrec :: ReadPrec ListSigningProfilesResponse
readList :: ReadS [ListSigningProfilesResponse]
$creadList :: ReadS [ListSigningProfilesResponse]
readsPrec :: Int -> ReadS ListSigningProfilesResponse
$creadsPrec :: Int -> ReadS ListSigningProfilesResponse
Prelude.Read, Int -> ListSigningProfilesResponse -> ShowS
[ListSigningProfilesResponse] -> ShowS
ListSigningProfilesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListSigningProfilesResponse] -> ShowS
$cshowList :: [ListSigningProfilesResponse] -> ShowS
show :: ListSigningProfilesResponse -> String
$cshow :: ListSigningProfilesResponse -> String
showsPrec :: Int -> ListSigningProfilesResponse -> ShowS
$cshowsPrec :: Int -> ListSigningProfilesResponse -> ShowS
Prelude.Show, forall x.
Rep ListSigningProfilesResponse x -> ListSigningProfilesResponse
forall x.
ListSigningProfilesResponse -> Rep ListSigningProfilesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListSigningProfilesResponse x -> ListSigningProfilesResponse
$cfrom :: forall x.
ListSigningProfilesResponse -> Rep ListSigningProfilesResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListSigningProfilesResponse' 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:
--
-- 'nextToken', 'listSigningProfilesResponse_nextToken' - Value for specifying the next set of paginated results to return.
--
-- 'profiles', 'listSigningProfilesResponse_profiles' - A list of profiles that are available in the AWS account. This includes
-- profiles with the status of @CANCELED@ if the @includeCanceled@
-- parameter is set to @true@.
--
-- 'httpStatus', 'listSigningProfilesResponse_httpStatus' - The response's http status code.
newListSigningProfilesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListSigningProfilesResponse
newListSigningProfilesResponse :: Int -> ListSigningProfilesResponse
newListSigningProfilesResponse Int
pHttpStatus_ =
  ListSigningProfilesResponse'
    { $sel:nextToken:ListSigningProfilesResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:profiles:ListSigningProfilesResponse' :: Maybe [SigningProfile]
profiles = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListSigningProfilesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Value for specifying the next set of paginated results to return.
listSigningProfilesResponse_nextToken :: Lens.Lens' ListSigningProfilesResponse (Prelude.Maybe Prelude.Text)
listSigningProfilesResponse_nextToken :: Lens' ListSigningProfilesResponse (Maybe Text)
listSigningProfilesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfilesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListSigningProfilesResponse' :: ListSigningProfilesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSigningProfilesResponse
s@ListSigningProfilesResponse' {} Maybe Text
a -> ListSigningProfilesResponse
s {$sel:nextToken:ListSigningProfilesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListSigningProfilesResponse)

-- | A list of profiles that are available in the AWS account. This includes
-- profiles with the status of @CANCELED@ if the @includeCanceled@
-- parameter is set to @true@.
listSigningProfilesResponse_profiles :: Lens.Lens' ListSigningProfilesResponse (Prelude.Maybe [SigningProfile])
listSigningProfilesResponse_profiles :: Lens' ListSigningProfilesResponse (Maybe [SigningProfile])
listSigningProfilesResponse_profiles = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfilesResponse' {Maybe [SigningProfile]
profiles :: Maybe [SigningProfile]
$sel:profiles:ListSigningProfilesResponse' :: ListSigningProfilesResponse -> Maybe [SigningProfile]
profiles} -> Maybe [SigningProfile]
profiles) (\s :: ListSigningProfilesResponse
s@ListSigningProfilesResponse' {} Maybe [SigningProfile]
a -> ListSigningProfilesResponse
s {$sel:profiles:ListSigningProfilesResponse' :: Maybe [SigningProfile]
profiles = Maybe [SigningProfile]
a} :: ListSigningProfilesResponse) 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.
listSigningProfilesResponse_httpStatus :: Lens.Lens' ListSigningProfilesResponse Prelude.Int
listSigningProfilesResponse_httpStatus :: Lens' ListSigningProfilesResponse Int
listSigningProfilesResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSigningProfilesResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListSigningProfilesResponse' :: ListSigningProfilesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListSigningProfilesResponse
s@ListSigningProfilesResponse' {} Int
a -> ListSigningProfilesResponse
s {$sel:httpStatus:ListSigningProfilesResponse' :: Int
httpStatus = Int
a} :: ListSigningProfilesResponse)

instance Prelude.NFData ListSigningProfilesResponse where
  rnf :: ListSigningProfilesResponse -> ()
rnf ListSigningProfilesResponse' {Int
Maybe [SigningProfile]
Maybe Text
httpStatus :: Int
profiles :: Maybe [SigningProfile]
nextToken :: Maybe Text
$sel:httpStatus:ListSigningProfilesResponse' :: ListSigningProfilesResponse -> Int
$sel:profiles:ListSigningProfilesResponse' :: ListSigningProfilesResponse -> Maybe [SigningProfile]
$sel:nextToken:ListSigningProfilesResponse' :: ListSigningProfilesResponse -> Maybe Text
..} =
    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 [SigningProfile]
profiles
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus