{-# 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.Config.ListStoredQueries
-- 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 the stored queries for a single Amazon Web Services account and a
-- single Amazon Web Services Region. The default is 100.
module Amazonka.Config.ListStoredQueries
  ( -- * Creating a Request
    ListStoredQueries (..),
    newListStoredQueries,

    -- * Request Lenses
    listStoredQueries_maxResults,
    listStoredQueries_nextToken,

    -- * Destructuring the Response
    ListStoredQueriesResponse (..),
    newListStoredQueriesResponse,

    -- * Response Lenses
    listStoredQueriesResponse_nextToken,
    listStoredQueriesResponse_storedQueryMetadata,
    listStoredQueriesResponse_httpStatus,
  )
where

import Amazonka.Config.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:/ 'newListStoredQueries' smart constructor.
data ListStoredQueries = ListStoredQueries'
  { -- | The maximum number of results to be returned with a single call.
    ListStoredQueries -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The nextToken string returned in a previous request that you use to
    -- request the next page of results in a paginated response.
    ListStoredQueries -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListStoredQueries -> ListStoredQueries -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListStoredQueries -> ListStoredQueries -> Bool
$c/= :: ListStoredQueries -> ListStoredQueries -> Bool
== :: ListStoredQueries -> ListStoredQueries -> Bool
$c== :: ListStoredQueries -> ListStoredQueries -> Bool
Prelude.Eq, ReadPrec [ListStoredQueries]
ReadPrec ListStoredQueries
Int -> ReadS ListStoredQueries
ReadS [ListStoredQueries]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListStoredQueries]
$creadListPrec :: ReadPrec [ListStoredQueries]
readPrec :: ReadPrec ListStoredQueries
$creadPrec :: ReadPrec ListStoredQueries
readList :: ReadS [ListStoredQueries]
$creadList :: ReadS [ListStoredQueries]
readsPrec :: Int -> ReadS ListStoredQueries
$creadsPrec :: Int -> ReadS ListStoredQueries
Prelude.Read, Int -> ListStoredQueries -> ShowS
[ListStoredQueries] -> ShowS
ListStoredQueries -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListStoredQueries] -> ShowS
$cshowList :: [ListStoredQueries] -> ShowS
show :: ListStoredQueries -> String
$cshow :: ListStoredQueries -> String
showsPrec :: Int -> ListStoredQueries -> ShowS
$cshowsPrec :: Int -> ListStoredQueries -> ShowS
Prelude.Show, forall x. Rep ListStoredQueries x -> ListStoredQueries
forall x. ListStoredQueries -> Rep ListStoredQueries x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListStoredQueries x -> ListStoredQueries
$cfrom :: forall x. ListStoredQueries -> Rep ListStoredQueries x
Prelude.Generic)

-- |
-- Create a value of 'ListStoredQueries' 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:
--
-- 'maxResults', 'listStoredQueries_maxResults' - The maximum number of results to be returned with a single call.
--
-- 'nextToken', 'listStoredQueries_nextToken' - The nextToken string returned in a previous request that you use to
-- request the next page of results in a paginated response.
newListStoredQueries ::
  ListStoredQueries
newListStoredQueries :: ListStoredQueries
newListStoredQueries =
  ListStoredQueries'
    { $sel:maxResults:ListStoredQueries' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListStoredQueries' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The maximum number of results to be returned with a single call.
listStoredQueries_maxResults :: Lens.Lens' ListStoredQueries (Prelude.Maybe Prelude.Natural)
listStoredQueries_maxResults :: Lens' ListStoredQueries (Maybe Natural)
listStoredQueries_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStoredQueries' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListStoredQueries' :: ListStoredQueries -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListStoredQueries
s@ListStoredQueries' {} Maybe Natural
a -> ListStoredQueries
s {$sel:maxResults:ListStoredQueries' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListStoredQueries)

-- | The nextToken string returned in a previous request that you use to
-- request the next page of results in a paginated response.
listStoredQueries_nextToken :: Lens.Lens' ListStoredQueries (Prelude.Maybe Prelude.Text)
listStoredQueries_nextToken :: Lens' ListStoredQueries (Maybe Text)
listStoredQueries_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStoredQueries' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListStoredQueries' :: ListStoredQueries -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListStoredQueries
s@ListStoredQueries' {} Maybe Text
a -> ListStoredQueries
s {$sel:nextToken:ListStoredQueries' :: Maybe Text
nextToken = Maybe Text
a} :: ListStoredQueries)

instance Core.AWSRequest ListStoredQueries where
  type
    AWSResponse ListStoredQueries =
      ListStoredQueriesResponse
  request :: (Service -> Service)
-> ListStoredQueries -> Request ListStoredQueries
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 ListStoredQueries
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListStoredQueries)))
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 [StoredQueryMetadata] -> Int -> ListStoredQueriesResponse
ListStoredQueriesResponse'
            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
"StoredQueryMetadata"
                            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 ListStoredQueries where
  hashWithSalt :: Int -> ListStoredQueries -> Int
hashWithSalt Int
_salt ListStoredQueries' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListStoredQueries' :: ListStoredQueries -> Maybe Text
$sel:maxResults:ListStoredQueries' :: ListStoredQueries -> Maybe Natural
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData ListStoredQueries where
  rnf :: ListStoredQueries -> ()
rnf ListStoredQueries' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListStoredQueries' :: ListStoredQueries -> Maybe Text
$sel:maxResults:ListStoredQueries' :: ListStoredQueries -> Maybe Natural
..} =
    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

instance Data.ToHeaders ListStoredQueries where
  toHeaders :: ListStoredQueries -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"StarlingDoveService.ListStoredQueries" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON ListStoredQueries where
  toJSON :: ListStoredQueries -> Value
toJSON ListStoredQueries' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListStoredQueries' :: ListStoredQueries -> Maybe Text
$sel:maxResults:ListStoredQueries' :: ListStoredQueries -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"MaxResults" 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 Natural
maxResults,
            (Key
"NextToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextToken
          ]
      )

instance Data.ToPath ListStoredQueries where
  toPath :: ListStoredQueries -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery ListStoredQueries where
  toQuery :: ListStoredQueries -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newListStoredQueriesResponse' smart constructor.
data ListStoredQueriesResponse = ListStoredQueriesResponse'
  { -- | If the previous paginated request didn\'t return all of the remaining
    -- results, the response object\'s @NextToken@ parameter value is set to a
    -- token. To retrieve the next set of results, call this action again and
    -- assign that token to the request object\'s @NextToken@ parameter. If
    -- there are no remaining results, the previous response object\'s
    -- @NextToken@ parameter is set to @null@.
    ListStoredQueriesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A list of @StoredQueryMetadata@ objects.
    ListStoredQueriesResponse -> Maybe [StoredQueryMetadata]
storedQueryMetadata :: Prelude.Maybe [StoredQueryMetadata],
    -- | The response's http status code.
    ListStoredQueriesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListStoredQueriesResponse -> ListStoredQueriesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListStoredQueriesResponse -> ListStoredQueriesResponse -> Bool
$c/= :: ListStoredQueriesResponse -> ListStoredQueriesResponse -> Bool
== :: ListStoredQueriesResponse -> ListStoredQueriesResponse -> Bool
$c== :: ListStoredQueriesResponse -> ListStoredQueriesResponse -> Bool
Prelude.Eq, ReadPrec [ListStoredQueriesResponse]
ReadPrec ListStoredQueriesResponse
Int -> ReadS ListStoredQueriesResponse
ReadS [ListStoredQueriesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListStoredQueriesResponse]
$creadListPrec :: ReadPrec [ListStoredQueriesResponse]
readPrec :: ReadPrec ListStoredQueriesResponse
$creadPrec :: ReadPrec ListStoredQueriesResponse
readList :: ReadS [ListStoredQueriesResponse]
$creadList :: ReadS [ListStoredQueriesResponse]
readsPrec :: Int -> ReadS ListStoredQueriesResponse
$creadsPrec :: Int -> ReadS ListStoredQueriesResponse
Prelude.Read, Int -> ListStoredQueriesResponse -> ShowS
[ListStoredQueriesResponse] -> ShowS
ListStoredQueriesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListStoredQueriesResponse] -> ShowS
$cshowList :: [ListStoredQueriesResponse] -> ShowS
show :: ListStoredQueriesResponse -> String
$cshow :: ListStoredQueriesResponse -> String
showsPrec :: Int -> ListStoredQueriesResponse -> ShowS
$cshowsPrec :: Int -> ListStoredQueriesResponse -> ShowS
Prelude.Show, forall x.
Rep ListStoredQueriesResponse x -> ListStoredQueriesResponse
forall x.
ListStoredQueriesResponse -> Rep ListStoredQueriesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListStoredQueriesResponse x -> ListStoredQueriesResponse
$cfrom :: forall x.
ListStoredQueriesResponse -> Rep ListStoredQueriesResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListStoredQueriesResponse' 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', 'listStoredQueriesResponse_nextToken' - If the previous paginated request didn\'t return all of the remaining
-- results, the response object\'s @NextToken@ parameter value is set to a
-- token. To retrieve the next set of results, call this action again and
-- assign that token to the request object\'s @NextToken@ parameter. If
-- there are no remaining results, the previous response object\'s
-- @NextToken@ parameter is set to @null@.
--
-- 'storedQueryMetadata', 'listStoredQueriesResponse_storedQueryMetadata' - A list of @StoredQueryMetadata@ objects.
--
-- 'httpStatus', 'listStoredQueriesResponse_httpStatus' - The response's http status code.
newListStoredQueriesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListStoredQueriesResponse
newListStoredQueriesResponse :: Int -> ListStoredQueriesResponse
newListStoredQueriesResponse Int
pHttpStatus_ =
  ListStoredQueriesResponse'
    { $sel:nextToken:ListStoredQueriesResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:storedQueryMetadata:ListStoredQueriesResponse' :: Maybe [StoredQueryMetadata]
storedQueryMetadata = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListStoredQueriesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | If the previous paginated request didn\'t return all of the remaining
-- results, the response object\'s @NextToken@ parameter value is set to a
-- token. To retrieve the next set of results, call this action again and
-- assign that token to the request object\'s @NextToken@ parameter. If
-- there are no remaining results, the previous response object\'s
-- @NextToken@ parameter is set to @null@.
listStoredQueriesResponse_nextToken :: Lens.Lens' ListStoredQueriesResponse (Prelude.Maybe Prelude.Text)
listStoredQueriesResponse_nextToken :: Lens' ListStoredQueriesResponse (Maybe Text)
listStoredQueriesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStoredQueriesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListStoredQueriesResponse' :: ListStoredQueriesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListStoredQueriesResponse
s@ListStoredQueriesResponse' {} Maybe Text
a -> ListStoredQueriesResponse
s {$sel:nextToken:ListStoredQueriesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListStoredQueriesResponse)

-- | A list of @StoredQueryMetadata@ objects.
listStoredQueriesResponse_storedQueryMetadata :: Lens.Lens' ListStoredQueriesResponse (Prelude.Maybe [StoredQueryMetadata])
listStoredQueriesResponse_storedQueryMetadata :: Lens' ListStoredQueriesResponse (Maybe [StoredQueryMetadata])
listStoredQueriesResponse_storedQueryMetadata = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStoredQueriesResponse' {Maybe [StoredQueryMetadata]
storedQueryMetadata :: Maybe [StoredQueryMetadata]
$sel:storedQueryMetadata:ListStoredQueriesResponse' :: ListStoredQueriesResponse -> Maybe [StoredQueryMetadata]
storedQueryMetadata} -> Maybe [StoredQueryMetadata]
storedQueryMetadata) (\s :: ListStoredQueriesResponse
s@ListStoredQueriesResponse' {} Maybe [StoredQueryMetadata]
a -> ListStoredQueriesResponse
s {$sel:storedQueryMetadata:ListStoredQueriesResponse' :: Maybe [StoredQueryMetadata]
storedQueryMetadata = Maybe [StoredQueryMetadata]
a} :: ListStoredQueriesResponse) 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.
listStoredQueriesResponse_httpStatus :: Lens.Lens' ListStoredQueriesResponse Prelude.Int
listStoredQueriesResponse_httpStatus :: Lens' ListStoredQueriesResponse Int
listStoredQueriesResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListStoredQueriesResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListStoredQueriesResponse' :: ListStoredQueriesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListStoredQueriesResponse
s@ListStoredQueriesResponse' {} Int
a -> ListStoredQueriesResponse
s {$sel:httpStatus:ListStoredQueriesResponse' :: Int
httpStatus = Int
a} :: ListStoredQueriesResponse)

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