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

    -- * Request Lenses
    searchSchemas_limit,
    searchSchemas_nextToken,
    searchSchemas_registryName,
    searchSchemas_keywords,

    -- * Destructuring the Response
    SearchSchemasResponse (..),
    newSearchSchemasResponse,

    -- * Response Lenses
    searchSchemasResponse_nextToken,
    searchSchemasResponse_schemas,
    searchSchemasResponse_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:/ 'newSearchSchemas' smart constructor.
data SearchSchemas = SearchSchemas'
  { SearchSchemas -> 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.
    SearchSchemas -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The name of the registry.
    SearchSchemas -> Text
registryName :: Prelude.Text,
    -- | Specifying this limits the results to only schemas that include the
    -- provided keywords.
    SearchSchemas -> Text
keywords :: Prelude.Text
  }
  deriving (SearchSchemas -> SearchSchemas -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchSchemas -> SearchSchemas -> Bool
$c/= :: SearchSchemas -> SearchSchemas -> Bool
== :: SearchSchemas -> SearchSchemas -> Bool
$c== :: SearchSchemas -> SearchSchemas -> Bool
Prelude.Eq, ReadPrec [SearchSchemas]
ReadPrec SearchSchemas
Int -> ReadS SearchSchemas
ReadS [SearchSchemas]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SearchSchemas]
$creadListPrec :: ReadPrec [SearchSchemas]
readPrec :: ReadPrec SearchSchemas
$creadPrec :: ReadPrec SearchSchemas
readList :: ReadS [SearchSchemas]
$creadList :: ReadS [SearchSchemas]
readsPrec :: Int -> ReadS SearchSchemas
$creadsPrec :: Int -> ReadS SearchSchemas
Prelude.Read, Int -> SearchSchemas -> ShowS
[SearchSchemas] -> ShowS
SearchSchemas -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SearchSchemas] -> ShowS
$cshowList :: [SearchSchemas] -> ShowS
show :: SearchSchemas -> String
$cshow :: SearchSchemas -> String
showsPrec :: Int -> SearchSchemas -> ShowS
$cshowsPrec :: Int -> SearchSchemas -> ShowS
Prelude.Show, forall x. Rep SearchSchemas x -> SearchSchemas
forall x. SearchSchemas -> Rep SearchSchemas x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SearchSchemas x -> SearchSchemas
$cfrom :: forall x. SearchSchemas -> Rep SearchSchemas x
Prelude.Generic)

-- |
-- Create a value of 'SearchSchemas' 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', 'searchSchemas_limit' - Undocumented member.
--
-- 'nextToken', 'searchSchemas_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.
--
-- 'registryName', 'searchSchemas_registryName' - The name of the registry.
--
-- 'keywords', 'searchSchemas_keywords' - Specifying this limits the results to only schemas that include the
-- provided keywords.
newSearchSchemas ::
  -- | 'registryName'
  Prelude.Text ->
  -- | 'keywords'
  Prelude.Text ->
  SearchSchemas
newSearchSchemas :: Text -> Text -> SearchSchemas
newSearchSchemas Text
pRegistryName_ Text
pKeywords_ =
  SearchSchemas'
    { $sel:limit:SearchSchemas' :: Maybe Int
limit = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:SearchSchemas' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:registryName:SearchSchemas' :: Text
registryName = Text
pRegistryName_,
      $sel:keywords:SearchSchemas' :: Text
keywords = Text
pKeywords_
    }

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

-- | 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.
searchSchemas_nextToken :: Lens.Lens' SearchSchemas (Prelude.Maybe Prelude.Text)
searchSchemas_nextToken :: Lens' SearchSchemas (Maybe Text)
searchSchemas_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchSchemas' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:SearchSchemas' :: SearchSchemas -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: SearchSchemas
s@SearchSchemas' {} Maybe Text
a -> SearchSchemas
s {$sel:nextToken:SearchSchemas' :: Maybe Text
nextToken = Maybe Text
a} :: SearchSchemas)

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

-- | Specifying this limits the results to only schemas that include the
-- provided keywords.
searchSchemas_keywords :: Lens.Lens' SearchSchemas Prelude.Text
searchSchemas_keywords :: Lens' SearchSchemas Text
searchSchemas_keywords = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchSchemas' {Text
keywords :: Text
$sel:keywords:SearchSchemas' :: SearchSchemas -> Text
keywords} -> Text
keywords) (\s :: SearchSchemas
s@SearchSchemas' {} Text
a -> SearchSchemas
s {$sel:keywords:SearchSchemas' :: Text
keywords = Text
a} :: SearchSchemas)

instance Core.AWSPager SearchSchemas where
  page :: SearchSchemas -> AWSResponse SearchSchemas -> Maybe SearchSchemas
page SearchSchemas
rq AWSResponse SearchSchemas
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse SearchSchemas
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchSchemasResponse (Maybe Text)
searchSchemasResponse_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 SearchSchemas
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchSchemasResponse (Maybe [SearchSchemaSummary])
searchSchemasResponse_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.$ SearchSchemas
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' SearchSchemas (Maybe Text)
searchSchemas_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse SearchSchemas
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' SearchSchemasResponse (Maybe Text)
searchSchemasResponse_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 SearchSchemas where
  type
    AWSResponse SearchSchemas =
      SearchSchemasResponse
  request :: (Service -> Service) -> SearchSchemas -> Request SearchSchemas
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 SearchSchemas
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SearchSchemas)))
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 [SearchSchemaSummary] -> Int -> SearchSchemasResponse
SearchSchemasResponse'
            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 SearchSchemas where
  hashWithSalt :: Int -> SearchSchemas -> Int
hashWithSalt Int
_salt SearchSchemas' {Maybe Int
Maybe Text
Text
keywords :: Text
registryName :: Text
nextToken :: Maybe Text
limit :: Maybe Int
$sel:keywords:SearchSchemas' :: SearchSchemas -> Text
$sel:registryName:SearchSchemas' :: SearchSchemas -> Text
$sel:nextToken:SearchSchemas' :: SearchSchemas -> Maybe Text
$sel:limit:SearchSchemas' :: SearchSchemas -> 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` Text
registryName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
keywords

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

instance Data.ToHeaders SearchSchemas where
  toHeaders :: SearchSchemas -> 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 SearchSchemas where
  toPath :: SearchSchemas -> ByteString
toPath SearchSchemas' {Maybe Int
Maybe Text
Text
keywords :: Text
registryName :: Text
nextToken :: Maybe Text
limit :: Maybe Int
$sel:keywords:SearchSchemas' :: SearchSchemas -> Text
$sel:registryName:SearchSchemas' :: SearchSchemas -> Text
$sel:nextToken:SearchSchemas' :: SearchSchemas -> Maybe Text
$sel:limit:SearchSchemas' :: SearchSchemas -> 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/search"
      ]

instance Data.ToQuery SearchSchemas where
  toQuery :: SearchSchemas -> QueryString
toQuery SearchSchemas' {Maybe Int
Maybe Text
Text
keywords :: Text
registryName :: Text
nextToken :: Maybe Text
limit :: Maybe Int
$sel:keywords:SearchSchemas' :: SearchSchemas -> Text
$sel:registryName:SearchSchemas' :: SearchSchemas -> Text
$sel:nextToken:SearchSchemas' :: SearchSchemas -> Maybe Text
$sel:limit:SearchSchemas' :: SearchSchemas -> 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
"keywords" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
keywords
      ]

-- | /See:/ 'newSearchSchemasResponse' smart constructor.
data SearchSchemasResponse = SearchSchemasResponse'
  { -- | 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.
    SearchSchemasResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | An array of SearchSchemaSummary information.
    SearchSchemasResponse -> Maybe [SearchSchemaSummary]
schemas :: Prelude.Maybe [SearchSchemaSummary],
    -- | The response's http status code.
    SearchSchemasResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (SearchSchemasResponse -> SearchSchemasResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchSchemasResponse -> SearchSchemasResponse -> Bool
$c/= :: SearchSchemasResponse -> SearchSchemasResponse -> Bool
== :: SearchSchemasResponse -> SearchSchemasResponse -> Bool
$c== :: SearchSchemasResponse -> SearchSchemasResponse -> Bool
Prelude.Eq, ReadPrec [SearchSchemasResponse]
ReadPrec SearchSchemasResponse
Int -> ReadS SearchSchemasResponse
ReadS [SearchSchemasResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SearchSchemasResponse]
$creadListPrec :: ReadPrec [SearchSchemasResponse]
readPrec :: ReadPrec SearchSchemasResponse
$creadPrec :: ReadPrec SearchSchemasResponse
readList :: ReadS [SearchSchemasResponse]
$creadList :: ReadS [SearchSchemasResponse]
readsPrec :: Int -> ReadS SearchSchemasResponse
$creadsPrec :: Int -> ReadS SearchSchemasResponse
Prelude.Read, Int -> SearchSchemasResponse -> ShowS
[SearchSchemasResponse] -> ShowS
SearchSchemasResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SearchSchemasResponse] -> ShowS
$cshowList :: [SearchSchemasResponse] -> ShowS
show :: SearchSchemasResponse -> String
$cshow :: SearchSchemasResponse -> String
showsPrec :: Int -> SearchSchemasResponse -> ShowS
$cshowsPrec :: Int -> SearchSchemasResponse -> ShowS
Prelude.Show, forall x. Rep SearchSchemasResponse x -> SearchSchemasResponse
forall x. SearchSchemasResponse -> Rep SearchSchemasResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SearchSchemasResponse x -> SearchSchemasResponse
$cfrom :: forall x. SearchSchemasResponse -> Rep SearchSchemasResponse x
Prelude.Generic)

-- |
-- Create a value of 'SearchSchemasResponse' 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', 'searchSchemasResponse_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', 'searchSchemasResponse_schemas' - An array of SearchSchemaSummary information.
--
-- 'httpStatus', 'searchSchemasResponse_httpStatus' - The response's http status code.
newSearchSchemasResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SearchSchemasResponse
newSearchSchemasResponse :: Int -> SearchSchemasResponse
newSearchSchemasResponse Int
pHttpStatus_ =
  SearchSchemasResponse'
    { $sel:nextToken:SearchSchemasResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:schemas:SearchSchemasResponse' :: Maybe [SearchSchemaSummary]
schemas = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SearchSchemasResponse' :: 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.
searchSchemasResponse_nextToken :: Lens.Lens' SearchSchemasResponse (Prelude.Maybe Prelude.Text)
searchSchemasResponse_nextToken :: Lens' SearchSchemasResponse (Maybe Text)
searchSchemasResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchSchemasResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:SearchSchemasResponse' :: SearchSchemasResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: SearchSchemasResponse
s@SearchSchemasResponse' {} Maybe Text
a -> SearchSchemasResponse
s {$sel:nextToken:SearchSchemasResponse' :: Maybe Text
nextToken = Maybe Text
a} :: SearchSchemasResponse)

-- | An array of SearchSchemaSummary information.
searchSchemasResponse_schemas :: Lens.Lens' SearchSchemasResponse (Prelude.Maybe [SearchSchemaSummary])
searchSchemasResponse_schemas :: Lens' SearchSchemasResponse (Maybe [SearchSchemaSummary])
searchSchemasResponse_schemas = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchSchemasResponse' {Maybe [SearchSchemaSummary]
schemas :: Maybe [SearchSchemaSummary]
$sel:schemas:SearchSchemasResponse' :: SearchSchemasResponse -> Maybe [SearchSchemaSummary]
schemas} -> Maybe [SearchSchemaSummary]
schemas) (\s :: SearchSchemasResponse
s@SearchSchemasResponse' {} Maybe [SearchSchemaSummary]
a -> SearchSchemasResponse
s {$sel:schemas:SearchSchemasResponse' :: Maybe [SearchSchemaSummary]
schemas = Maybe [SearchSchemaSummary]
a} :: SearchSchemasResponse) 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.
searchSchemasResponse_httpStatus :: Lens.Lens' SearchSchemasResponse Prelude.Int
searchSchemasResponse_httpStatus :: Lens' SearchSchemasResponse Int
searchSchemasResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchSchemasResponse' {Int
httpStatus :: Int
$sel:httpStatus:SearchSchemasResponse' :: SearchSchemasResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: SearchSchemasResponse
s@SearchSchemasResponse' {} Int
a -> SearchSchemasResponse
s {$sel:httpStatus:SearchSchemasResponse' :: Int
httpStatus = Int
a} :: SearchSchemasResponse)

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