{-# 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.LexModels.GetSlotTypes
-- 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 slot type information as follows:
--
-- -   If you specify the @nameContains@ field, returns the @$LATEST@
--     version of all slot types that contain the specified string.
--
-- -   If you don\'t specify the @nameContains@ field, returns information
--     about the @$LATEST@ version of all slot types.
--
-- The operation requires permission for the @lex:GetSlotTypes@ action.
--
-- This operation returns paginated results.
module Amazonka.LexModels.GetSlotTypes
  ( -- * Creating a Request
    GetSlotTypes (..),
    newGetSlotTypes,

    -- * Request Lenses
    getSlotTypes_maxResults,
    getSlotTypes_nameContains,
    getSlotTypes_nextToken,

    -- * Destructuring the Response
    GetSlotTypesResponse (..),
    newGetSlotTypesResponse,

    -- * Response Lenses
    getSlotTypesResponse_nextToken,
    getSlotTypesResponse_slotTypes,
    getSlotTypesResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.LexModels.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newGetSlotTypes' smart constructor.
data GetSlotTypes = GetSlotTypes'
  { -- | The maximum number of slot types to return in the response. The default
    -- is 10.
    GetSlotTypes -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | Substring to match in slot type names. A slot type will be returned if
    -- any part of its name matches the substring. For example, \"xyz\" matches
    -- both \"xyzabc\" and \"abcxyz.\"
    GetSlotTypes -> Maybe Text
nameContains :: Prelude.Maybe Prelude.Text,
    -- | A pagination token that fetches the next page of slot types. If the
    -- response to this API call is truncated, Amazon Lex returns a pagination
    -- token in the response. To fetch next page of slot types, specify the
    -- pagination token in the next request.
    GetSlotTypes -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (GetSlotTypes -> GetSlotTypes -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetSlotTypes -> GetSlotTypes -> Bool
$c/= :: GetSlotTypes -> GetSlotTypes -> Bool
== :: GetSlotTypes -> GetSlotTypes -> Bool
$c== :: GetSlotTypes -> GetSlotTypes -> Bool
Prelude.Eq, ReadPrec [GetSlotTypes]
ReadPrec GetSlotTypes
Int -> ReadS GetSlotTypes
ReadS [GetSlotTypes]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetSlotTypes]
$creadListPrec :: ReadPrec [GetSlotTypes]
readPrec :: ReadPrec GetSlotTypes
$creadPrec :: ReadPrec GetSlotTypes
readList :: ReadS [GetSlotTypes]
$creadList :: ReadS [GetSlotTypes]
readsPrec :: Int -> ReadS GetSlotTypes
$creadsPrec :: Int -> ReadS GetSlotTypes
Prelude.Read, Int -> GetSlotTypes -> ShowS
[GetSlotTypes] -> ShowS
GetSlotTypes -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetSlotTypes] -> ShowS
$cshowList :: [GetSlotTypes] -> ShowS
show :: GetSlotTypes -> String
$cshow :: GetSlotTypes -> String
showsPrec :: Int -> GetSlotTypes -> ShowS
$cshowsPrec :: Int -> GetSlotTypes -> ShowS
Prelude.Show, forall x. Rep GetSlotTypes x -> GetSlotTypes
forall x. GetSlotTypes -> Rep GetSlotTypes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetSlotTypes x -> GetSlotTypes
$cfrom :: forall x. GetSlotTypes -> Rep GetSlotTypes x
Prelude.Generic)

-- |
-- Create a value of 'GetSlotTypes' 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', 'getSlotTypes_maxResults' - The maximum number of slot types to return in the response. The default
-- is 10.
--
-- 'nameContains', 'getSlotTypes_nameContains' - Substring to match in slot type names. A slot type will be returned if
-- any part of its name matches the substring. For example, \"xyz\" matches
-- both \"xyzabc\" and \"abcxyz.\"
--
-- 'nextToken', 'getSlotTypes_nextToken' - A pagination token that fetches the next page of slot types. If the
-- response to this API call is truncated, Amazon Lex returns a pagination
-- token in the response. To fetch next page of slot types, specify the
-- pagination token in the next request.
newGetSlotTypes ::
  GetSlotTypes
newGetSlotTypes :: GetSlotTypes
newGetSlotTypes =
  GetSlotTypes'
    { $sel:maxResults:GetSlotTypes' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nameContains:GetSlotTypes' :: Maybe Text
nameContains = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:GetSlotTypes' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | The maximum number of slot types to return in the response. The default
-- is 10.
getSlotTypes_maxResults :: Lens.Lens' GetSlotTypes (Prelude.Maybe Prelude.Natural)
getSlotTypes_maxResults :: Lens' GetSlotTypes (Maybe Natural)
getSlotTypes_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSlotTypes' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:GetSlotTypes' :: GetSlotTypes -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: GetSlotTypes
s@GetSlotTypes' {} Maybe Natural
a -> GetSlotTypes
s {$sel:maxResults:GetSlotTypes' :: Maybe Natural
maxResults = Maybe Natural
a} :: GetSlotTypes)

-- | Substring to match in slot type names. A slot type will be returned if
-- any part of its name matches the substring. For example, \"xyz\" matches
-- both \"xyzabc\" and \"abcxyz.\"
getSlotTypes_nameContains :: Lens.Lens' GetSlotTypes (Prelude.Maybe Prelude.Text)
getSlotTypes_nameContains :: Lens' GetSlotTypes (Maybe Text)
getSlotTypes_nameContains = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSlotTypes' {Maybe Text
nameContains :: Maybe Text
$sel:nameContains:GetSlotTypes' :: GetSlotTypes -> Maybe Text
nameContains} -> Maybe Text
nameContains) (\s :: GetSlotTypes
s@GetSlotTypes' {} Maybe Text
a -> GetSlotTypes
s {$sel:nameContains:GetSlotTypes' :: Maybe Text
nameContains = Maybe Text
a} :: GetSlotTypes)

-- | A pagination token that fetches the next page of slot types. If the
-- response to this API call is truncated, Amazon Lex returns a pagination
-- token in the response. To fetch next page of slot types, specify the
-- pagination token in the next request.
getSlotTypes_nextToken :: Lens.Lens' GetSlotTypes (Prelude.Maybe Prelude.Text)
getSlotTypes_nextToken :: Lens' GetSlotTypes (Maybe Text)
getSlotTypes_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSlotTypes' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetSlotTypes' :: GetSlotTypes -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetSlotTypes
s@GetSlotTypes' {} Maybe Text
a -> GetSlotTypes
s {$sel:nextToken:GetSlotTypes' :: Maybe Text
nextToken = Maybe Text
a} :: GetSlotTypes)

instance Core.AWSPager GetSlotTypes where
  page :: GetSlotTypes -> AWSResponse GetSlotTypes -> Maybe GetSlotTypes
page GetSlotTypes
rq AWSResponse GetSlotTypes
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse GetSlotTypes
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' GetSlotTypesResponse (Maybe Text)
getSlotTypesResponse_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 GetSlotTypes
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' GetSlotTypesResponse (Maybe [SlotTypeMetadata])
getSlotTypesResponse_slotTypes
            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.$ GetSlotTypes
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' GetSlotTypes (Maybe Text)
getSlotTypes_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse GetSlotTypes
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' GetSlotTypesResponse (Maybe Text)
getSlotTypesResponse_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 GetSlotTypes where
  type AWSResponse GetSlotTypes = GetSlotTypesResponse
  request :: (Service -> Service) -> GetSlotTypes -> Request GetSlotTypes
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 GetSlotTypes
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse GetSlotTypes)))
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 [SlotTypeMetadata] -> Int -> GetSlotTypesResponse
GetSlotTypesResponse'
            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
"slotTypes" 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 GetSlotTypes where
  hashWithSalt :: Int -> GetSlotTypes -> Int
hashWithSalt Int
_salt GetSlotTypes' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
nameContains :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:GetSlotTypes' :: GetSlotTypes -> Maybe Text
$sel:nameContains:GetSlotTypes' :: GetSlotTypes -> Maybe Text
$sel:maxResults:GetSlotTypes' :: GetSlotTypes -> 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
nameContains
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData GetSlotTypes where
  rnf :: GetSlotTypes -> ()
rnf GetSlotTypes' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
nameContains :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:GetSlotTypes' :: GetSlotTypes -> Maybe Text
$sel:nameContains:GetSlotTypes' :: GetSlotTypes -> Maybe Text
$sel:maxResults:GetSlotTypes' :: GetSlotTypes -> 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
nameContains
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken

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

instance Data.ToQuery GetSlotTypes where
  toQuery :: GetSlotTypes -> QueryString
toQuery GetSlotTypes' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
nameContains :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:GetSlotTypes' :: GetSlotTypes -> Maybe Text
$sel:nameContains:GetSlotTypes' :: GetSlotTypes -> Maybe Text
$sel:maxResults:GetSlotTypes' :: GetSlotTypes -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"nameContains" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nameContains,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken
      ]

-- | /See:/ 'newGetSlotTypesResponse' smart constructor.
data GetSlotTypesResponse = GetSlotTypesResponse'
  { -- | If the response is truncated, it includes a pagination token that you
    -- can specify in your next request to fetch the next page of slot types.
    GetSlotTypesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | An array of objects, one for each slot type, that provides information
    -- such as the name of the slot type, the version, and a description.
    GetSlotTypesResponse -> Maybe [SlotTypeMetadata]
slotTypes :: Prelude.Maybe [SlotTypeMetadata],
    -- | The response's http status code.
    GetSlotTypesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetSlotTypesResponse -> GetSlotTypesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetSlotTypesResponse -> GetSlotTypesResponse -> Bool
$c/= :: GetSlotTypesResponse -> GetSlotTypesResponse -> Bool
== :: GetSlotTypesResponse -> GetSlotTypesResponse -> Bool
$c== :: GetSlotTypesResponse -> GetSlotTypesResponse -> Bool
Prelude.Eq, ReadPrec [GetSlotTypesResponse]
ReadPrec GetSlotTypesResponse
Int -> ReadS GetSlotTypesResponse
ReadS [GetSlotTypesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetSlotTypesResponse]
$creadListPrec :: ReadPrec [GetSlotTypesResponse]
readPrec :: ReadPrec GetSlotTypesResponse
$creadPrec :: ReadPrec GetSlotTypesResponse
readList :: ReadS [GetSlotTypesResponse]
$creadList :: ReadS [GetSlotTypesResponse]
readsPrec :: Int -> ReadS GetSlotTypesResponse
$creadsPrec :: Int -> ReadS GetSlotTypesResponse
Prelude.Read, Int -> GetSlotTypesResponse -> ShowS
[GetSlotTypesResponse] -> ShowS
GetSlotTypesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetSlotTypesResponse] -> ShowS
$cshowList :: [GetSlotTypesResponse] -> ShowS
show :: GetSlotTypesResponse -> String
$cshow :: GetSlotTypesResponse -> String
showsPrec :: Int -> GetSlotTypesResponse -> ShowS
$cshowsPrec :: Int -> GetSlotTypesResponse -> ShowS
Prelude.Show, forall x. Rep GetSlotTypesResponse x -> GetSlotTypesResponse
forall x. GetSlotTypesResponse -> Rep GetSlotTypesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetSlotTypesResponse x -> GetSlotTypesResponse
$cfrom :: forall x. GetSlotTypesResponse -> Rep GetSlotTypesResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetSlotTypesResponse' 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', 'getSlotTypesResponse_nextToken' - If the response is truncated, it includes a pagination token that you
-- can specify in your next request to fetch the next page of slot types.
--
-- 'slotTypes', 'getSlotTypesResponse_slotTypes' - An array of objects, one for each slot type, that provides information
-- such as the name of the slot type, the version, and a description.
--
-- 'httpStatus', 'getSlotTypesResponse_httpStatus' - The response's http status code.
newGetSlotTypesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetSlotTypesResponse
newGetSlotTypesResponse :: Int -> GetSlotTypesResponse
newGetSlotTypesResponse Int
pHttpStatus_ =
  GetSlotTypesResponse'
    { $sel:nextToken:GetSlotTypesResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:slotTypes:GetSlotTypesResponse' :: Maybe [SlotTypeMetadata]
slotTypes = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetSlotTypesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | If the response is truncated, it includes a pagination token that you
-- can specify in your next request to fetch the next page of slot types.
getSlotTypesResponse_nextToken :: Lens.Lens' GetSlotTypesResponse (Prelude.Maybe Prelude.Text)
getSlotTypesResponse_nextToken :: Lens' GetSlotTypesResponse (Maybe Text)
getSlotTypesResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSlotTypesResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetSlotTypesResponse' :: GetSlotTypesResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetSlotTypesResponse
s@GetSlotTypesResponse' {} Maybe Text
a -> GetSlotTypesResponse
s {$sel:nextToken:GetSlotTypesResponse' :: Maybe Text
nextToken = Maybe Text
a} :: GetSlotTypesResponse)

-- | An array of objects, one for each slot type, that provides information
-- such as the name of the slot type, the version, and a description.
getSlotTypesResponse_slotTypes :: Lens.Lens' GetSlotTypesResponse (Prelude.Maybe [SlotTypeMetadata])
getSlotTypesResponse_slotTypes :: Lens' GetSlotTypesResponse (Maybe [SlotTypeMetadata])
getSlotTypesResponse_slotTypes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSlotTypesResponse' {Maybe [SlotTypeMetadata]
slotTypes :: Maybe [SlotTypeMetadata]
$sel:slotTypes:GetSlotTypesResponse' :: GetSlotTypesResponse -> Maybe [SlotTypeMetadata]
slotTypes} -> Maybe [SlotTypeMetadata]
slotTypes) (\s :: GetSlotTypesResponse
s@GetSlotTypesResponse' {} Maybe [SlotTypeMetadata]
a -> GetSlotTypesResponse
s {$sel:slotTypes:GetSlotTypesResponse' :: Maybe [SlotTypeMetadata]
slotTypes = Maybe [SlotTypeMetadata]
a} :: GetSlotTypesResponse) 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.
getSlotTypesResponse_httpStatus :: Lens.Lens' GetSlotTypesResponse Prelude.Int
getSlotTypesResponse_httpStatus :: Lens' GetSlotTypesResponse Int
getSlotTypesResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetSlotTypesResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetSlotTypesResponse' :: GetSlotTypesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetSlotTypesResponse
s@GetSlotTypesResponse' {} Int
a -> GetSlotTypesResponse
s {$sel:httpStatus:GetSlotTypesResponse' :: Int
httpStatus = Int
a} :: GetSlotTypesResponse)

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