{-# 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.Schemas.ListSchemas
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- List the schemas.
--
-- This operation returns paginated results.
module Amazonka.Schemas.ListSchemas
  ( -- * Creating a Request
    ListSchemas (..),
    newListSchemas,

    -- * Request Lenses
    listSchemas_limit,
    listSchemas_nextToken,
    listSchemas_schemaNamePrefix,
    listSchemas_registryName,

    -- * Destructuring the Response
    ListSchemasResponse (..),
    newListSchemasResponse,

    -- * Response Lenses
    listSchemasResponse_nextToken,
    listSchemasResponse_schemas,
    listSchemasResponse_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.Schemas.Types

-- | /See:/ 'newListSchemas' smart constructor.
data ListSchemas = ListSchemas'
  { ListSchemas -> Maybe Int
limit :: Prelude.Maybe Prelude.Int,
    -- | The token that specifies the next page of results to return. To request
    -- the first page, leave NextToken empty. The token will expire in 24
    -- hours, and cannot be shared with other accounts.
    ListSchemas -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Specifying this limits the results to only those schema names that start
    -- with the specified prefix.
    ListSchemas -> Maybe Text
schemaNamePrefix :: Prelude.Maybe Prelude.Text,
    -- | The name of the registry.
    ListSchemas -> Text
registryName :: Prelude.Text
  }
  deriving (ListSchemas -> ListSchemas -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListSchemas -> ListSchemas -> Bool
$c/= :: ListSchemas -> ListSchemas -> Bool
== :: ListSchemas -> ListSchemas -> Bool
$c== :: ListSchemas -> ListSchemas -> Bool
Prelude.Eq, ReadPrec [ListSchemas]
ReadPrec ListSchemas
Int -> ReadS ListSchemas
ReadS [ListSchemas]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListSchemas]
$creadListPrec :: ReadPrec [ListSchemas]
readPrec :: ReadPrec ListSchemas
$creadPrec :: ReadPrec ListSchemas
readList :: ReadS [ListSchemas]
$creadList :: ReadS [ListSchemas]
readsPrec :: Int -> ReadS ListSchemas
$creadsPrec :: Int -> ReadS ListSchemas
Prelude.Read, Int -> ListSchemas -> ShowS
[ListSchemas] -> ShowS
ListSchemas -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListSchemas] -> ShowS
$cshowList :: [ListSchemas] -> ShowS
show :: ListSchemas -> String
$cshow :: ListSchemas -> String
showsPrec :: Int -> ListSchemas -> ShowS
$cshowsPrec :: Int -> ListSchemas -> ShowS
Prelude.Show, forall x. Rep ListSchemas x -> ListSchemas
forall x. ListSchemas -> Rep ListSchemas x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListSchemas x -> ListSchemas
$cfrom :: forall x. ListSchemas -> Rep ListSchemas x
Prelude.Generic)

-- |
-- Create a value of 'ListSchemas' 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:
--
-- 'limit', 'listSchemas_limit' - Undocumented member.
--
-- 'nextToken', 'listSchemas_nextToken' - The token that specifies the next page of results to return. To request
-- the first page, leave NextToken empty. The token will expire in 24
-- hours, and cannot be shared with other accounts.
--
-- 'schemaNamePrefix', 'listSchemas_schemaNamePrefix' - Specifying this limits the results to only those schema names that start
-- with the specified prefix.
--
-- 'registryName', 'listSchemas_registryName' - The name of the registry.
newListSchemas ::
  -- | 'registryName'
  Prelude.Text ->
  ListSchemas
newListSchemas :: Text -> ListSchemas
newListSchemas Text
pRegistryName_ =
  ListSchemas'
    { $sel:limit:ListSchemas' :: Maybe Int
limit = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListSchemas' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaNamePrefix:ListSchemas' :: Maybe Text
schemaNamePrefix = forall a. Maybe a
Prelude.Nothing,
      $sel:registryName:ListSchemas' :: Text
registryName = Text
pRegistryName_
    }

-- | Undocumented member.
listSchemas_limit :: Lens.Lens' ListSchemas (Prelude.Maybe Prelude.Int)
listSchemas_limit :: Lens' ListSchemas (Maybe Int)
listSchemas_limit = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSchemas' {Maybe Int
limit :: Maybe Int
$sel:limit:ListSchemas' :: ListSchemas -> Maybe Int
limit} -> Maybe Int
limit) (\s :: ListSchemas
s@ListSchemas' {} Maybe Int
a -> ListSchemas
s {$sel:limit:ListSchemas' :: Maybe Int
limit = Maybe Int
a} :: ListSchemas)

-- | The token that specifies the next page of results to return. To request
-- the first page, leave NextToken empty. The token will expire in 24
-- hours, and cannot be shared with other accounts.
listSchemas_nextToken :: Lens.Lens' ListSchemas (Prelude.Maybe Prelude.Text)
listSchemas_nextToken :: Lens' ListSchemas (Maybe Text)
listSchemas_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSchemas' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListSchemas' :: ListSchemas -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSchemas
s@ListSchemas' {} Maybe Text
a -> ListSchemas
s {$sel:nextToken:ListSchemas' :: Maybe Text
nextToken = Maybe Text
a} :: ListSchemas)

-- | Specifying this limits the results to only those schema names that start
-- with the specified prefix.
listSchemas_schemaNamePrefix :: Lens.Lens' ListSchemas (Prelude.Maybe Prelude.Text)
listSchemas_schemaNamePrefix :: Lens' ListSchemas (Maybe Text)
listSchemas_schemaNamePrefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSchemas' {Maybe Text
schemaNamePrefix :: Maybe Text
$sel:schemaNamePrefix:ListSchemas' :: ListSchemas -> Maybe Text
schemaNamePrefix} -> Maybe Text
schemaNamePrefix) (\s :: ListSchemas
s@ListSchemas' {} Maybe Text
a -> ListSchemas
s {$sel:schemaNamePrefix:ListSchemas' :: Maybe Text
schemaNamePrefix = Maybe Text
a} :: ListSchemas)

-- | The name of the registry.
listSchemas_registryName :: Lens.Lens' ListSchemas Prelude.Text
listSchemas_registryName :: Lens' ListSchemas Text
listSchemas_registryName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSchemas' {Text
registryName :: Text
$sel:registryName:ListSchemas' :: ListSchemas -> Text
registryName} -> Text
registryName) (\s :: ListSchemas
s@ListSchemas' {} Text
a -> ListSchemas
s {$sel:registryName:ListSchemas' :: Text
registryName = Text
a} :: ListSchemas)

instance Core.AWSPager ListSchemas where
  page :: ListSchemas -> AWSResponse ListSchemas -> Maybe ListSchemas
page ListSchemas
rq AWSResponse ListSchemas
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListSchemas
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListSchemasResponse (Maybe Text)
listSchemasResponse_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 ListSchemas
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListSchemasResponse (Maybe [SchemaSummary])
listSchemasResponse_schemas
            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.$ ListSchemas
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListSchemas (Maybe Text)
listSchemas_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListSchemas
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListSchemasResponse (Maybe Text)
listSchemasResponse_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 ListSchemas where
  type AWSResponse ListSchemas = ListSchemasResponse
  request :: (Service -> Service) -> ListSchemas -> Request ListSchemas
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 ListSchemas
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListSchemas)))
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 [SchemaSummary] -> Int -> ListSchemasResponse
ListSchemasResponse'
            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
"Schemas" 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 ListSchemas where
  hashWithSalt :: Int -> ListSchemas -> Int
hashWithSalt Int
_salt ListSchemas' {Maybe Int
Maybe Text
Text
registryName :: Text
schemaNamePrefix :: Maybe Text
nextToken :: Maybe Text
limit :: Maybe Int
$sel:registryName:ListSchemas' :: ListSchemas -> Text
$sel:schemaNamePrefix:ListSchemas' :: ListSchemas -> Maybe Text
$sel:nextToken:ListSchemas' :: ListSchemas -> Maybe Text
$sel:limit:ListSchemas' :: ListSchemas -> Maybe Int
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
limit
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
schemaNamePrefix
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
registryName

instance Prelude.NFData ListSchemas where
  rnf :: ListSchemas -> ()
rnf ListSchemas' {Maybe Int
Maybe Text
Text
registryName :: Text
schemaNamePrefix :: Maybe Text
nextToken :: Maybe Text
limit :: Maybe Int
$sel:registryName:ListSchemas' :: ListSchemas -> Text
$sel:schemaNamePrefix:ListSchemas' :: ListSchemas -> Maybe Text
$sel:nextToken:ListSchemas' :: ListSchemas -> Maybe Text
$sel:limit:ListSchemas' :: ListSchemas -> Maybe Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
limit
      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
schemaNamePrefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
registryName

instance Data.ToHeaders ListSchemas where
  toHeaders :: ListSchemas -> 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 ListSchemas where
  toPath :: ListSchemas -> ByteString
toPath ListSchemas' {Maybe Int
Maybe Text
Text
registryName :: Text
schemaNamePrefix :: Maybe Text
nextToken :: Maybe Text
limit :: Maybe Int
$sel:registryName:ListSchemas' :: ListSchemas -> Text
$sel:schemaNamePrefix:ListSchemas' :: ListSchemas -> Maybe Text
$sel:nextToken:ListSchemas' :: ListSchemas -> Maybe Text
$sel:limit:ListSchemas' :: ListSchemas -> Maybe Int
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/v1/registries/name/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
registryName,
        ByteString
"/schemas"
      ]

instance Data.ToQuery ListSchemas where
  toQuery :: ListSchemas -> QueryString
toQuery ListSchemas' {Maybe Int
Maybe Text
Text
registryName :: Text
schemaNamePrefix :: Maybe Text
nextToken :: Maybe Text
limit :: Maybe Int
$sel:registryName:ListSchemas' :: ListSchemas -> Text
$sel:schemaNamePrefix:ListSchemas' :: ListSchemas -> Maybe Text
$sel:nextToken:ListSchemas' :: ListSchemas -> Maybe Text
$sel:limit:ListSchemas' :: ListSchemas -> Maybe Int
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"limit" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
limit,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        ByteString
"schemaNamePrefix" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
schemaNamePrefix
      ]

-- | /See:/ 'newListSchemasResponse' smart constructor.
data ListSchemasResponse = ListSchemasResponse'
  { -- | The token that specifies the next page of results to return. To request
    -- the first page, leave NextToken empty. The token will expire in 24
    -- hours, and cannot be shared with other accounts.
    ListSchemasResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | An array of schema summaries.
    ListSchemasResponse -> Maybe [SchemaSummary]
schemas :: Prelude.Maybe [SchemaSummary],
    -- | The response's http status code.
    ListSchemasResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListSchemasResponse -> ListSchemasResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListSchemasResponse -> ListSchemasResponse -> Bool
$c/= :: ListSchemasResponse -> ListSchemasResponse -> Bool
== :: ListSchemasResponse -> ListSchemasResponse -> Bool
$c== :: ListSchemasResponse -> ListSchemasResponse -> Bool
Prelude.Eq, ReadPrec [ListSchemasResponse]
ReadPrec ListSchemasResponse
Int -> ReadS ListSchemasResponse
ReadS [ListSchemasResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListSchemasResponse]
$creadListPrec :: ReadPrec [ListSchemasResponse]
readPrec :: ReadPrec ListSchemasResponse
$creadPrec :: ReadPrec ListSchemasResponse
readList :: ReadS [ListSchemasResponse]
$creadList :: ReadS [ListSchemasResponse]
readsPrec :: Int -> ReadS ListSchemasResponse
$creadsPrec :: Int -> ReadS ListSchemasResponse
Prelude.Read, Int -> ListSchemasResponse -> ShowS
[ListSchemasResponse] -> ShowS
ListSchemasResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListSchemasResponse] -> ShowS
$cshowList :: [ListSchemasResponse] -> ShowS
show :: ListSchemasResponse -> String
$cshow :: ListSchemasResponse -> String
showsPrec :: Int -> ListSchemasResponse -> ShowS
$cshowsPrec :: Int -> ListSchemasResponse -> ShowS
Prelude.Show, forall x. Rep ListSchemasResponse x -> ListSchemasResponse
forall x. ListSchemasResponse -> Rep ListSchemasResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListSchemasResponse x -> ListSchemasResponse
$cfrom :: forall x. ListSchemasResponse -> Rep ListSchemasResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListSchemasResponse' 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', 'listSchemasResponse_nextToken' - The token that specifies the next page of results to return. To request
-- the first page, leave NextToken empty. The token will expire in 24
-- hours, and cannot be shared with other accounts.
--
-- 'schemas', 'listSchemasResponse_schemas' - An array of schema summaries.
--
-- 'httpStatus', 'listSchemasResponse_httpStatus' - The response's http status code.
newListSchemasResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListSchemasResponse
newListSchemasResponse :: Int -> ListSchemasResponse
newListSchemasResponse Int
pHttpStatus_ =
  ListSchemasResponse'
    { $sel:nextToken:ListSchemasResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:schemas:ListSchemasResponse' :: Maybe [SchemaSummary]
schemas = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListSchemasResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The token that specifies the next page of results to return. To request
-- the first page, leave NextToken empty. The token will expire in 24
-- hours, and cannot be shared with other accounts.
listSchemasResponse_nextToken :: Lens.Lens' ListSchemasResponse (Prelude.Maybe Prelude.Text)
listSchemasResponse_nextToken :: Lens' ListSchemasResponse (Maybe Text)
listSchemasResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSchemasResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListSchemasResponse' :: ListSchemasResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSchemasResponse
s@ListSchemasResponse' {} Maybe Text
a -> ListSchemasResponse
s {$sel:nextToken:ListSchemasResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListSchemasResponse)

-- | An array of schema summaries.
listSchemasResponse_schemas :: Lens.Lens' ListSchemasResponse (Prelude.Maybe [SchemaSummary])
listSchemasResponse_schemas :: Lens' ListSchemasResponse (Maybe [SchemaSummary])
listSchemasResponse_schemas = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSchemasResponse' {Maybe [SchemaSummary]
schemas :: Maybe [SchemaSummary]
$sel:schemas:ListSchemasResponse' :: ListSchemasResponse -> Maybe [SchemaSummary]
schemas} -> Maybe [SchemaSummary]
schemas) (\s :: ListSchemasResponse
s@ListSchemasResponse' {} Maybe [SchemaSummary]
a -> ListSchemasResponse
s {$sel:schemas:ListSchemasResponse' :: Maybe [SchemaSummary]
schemas = Maybe [SchemaSummary]
a} :: ListSchemasResponse) 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.
listSchemasResponse_httpStatus :: Lens.Lens' ListSchemasResponse Prelude.Int
listSchemasResponse_httpStatus :: Lens' ListSchemasResponse Int
listSchemasResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSchemasResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListSchemasResponse' :: ListSchemasResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListSchemasResponse
s@ListSchemasResponse' {} Int
a -> ListSchemasResponse
s {$sel:httpStatus:ListSchemasResponse' :: Int
httpStatus = Int
a} :: ListSchemasResponse)

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