{-# 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.GetBotAliases
-- 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 a list of aliases for a specified Amazon Lex bot.
--
-- This operation requires permissions for the @lex:GetBotAliases@ action.
--
-- This operation returns paginated results.
module Amazonka.LexModels.GetBotAliases
  ( -- * Creating a Request
    GetBotAliases (..),
    newGetBotAliases,

    -- * Request Lenses
    getBotAliases_maxResults,
    getBotAliases_nameContains,
    getBotAliases_nextToken,
    getBotAliases_botName,

    -- * Destructuring the Response
    GetBotAliasesResponse (..),
    newGetBotAliasesResponse,

    -- * Response Lenses
    getBotAliasesResponse_botAliases,
    getBotAliasesResponse_nextToken,
    getBotAliasesResponse_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:/ 'newGetBotAliases' smart constructor.
data GetBotAliases = GetBotAliases'
  { -- | The maximum number of aliases to return in the response. The default is
    -- 50. .
    GetBotAliases -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | Substring to match in bot alias names. An alias will be returned if any
    -- part of its name matches the substring. For example, \"xyz\" matches
    -- both \"xyzabc\" and \"abcxyz.\"
    GetBotAliases -> Maybe Text
nameContains :: Prelude.Maybe Prelude.Text,
    -- | A pagination token for fetching the next page of aliases. If the
    -- response to this call is truncated, Amazon Lex returns a pagination
    -- token in the response. To fetch the next page of aliases, specify the
    -- pagination token in the next request.
    GetBotAliases -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The name of the bot.
    GetBotAliases -> Text
botName :: Prelude.Text
  }
  deriving (GetBotAliases -> GetBotAliases -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetBotAliases -> GetBotAliases -> Bool
$c/= :: GetBotAliases -> GetBotAliases -> Bool
== :: GetBotAliases -> GetBotAliases -> Bool
$c== :: GetBotAliases -> GetBotAliases -> Bool
Prelude.Eq, ReadPrec [GetBotAliases]
ReadPrec GetBotAliases
Int -> ReadS GetBotAliases
ReadS [GetBotAliases]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetBotAliases]
$creadListPrec :: ReadPrec [GetBotAliases]
readPrec :: ReadPrec GetBotAliases
$creadPrec :: ReadPrec GetBotAliases
readList :: ReadS [GetBotAliases]
$creadList :: ReadS [GetBotAliases]
readsPrec :: Int -> ReadS GetBotAliases
$creadsPrec :: Int -> ReadS GetBotAliases
Prelude.Read, Int -> GetBotAliases -> ShowS
[GetBotAliases] -> ShowS
GetBotAliases -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetBotAliases] -> ShowS
$cshowList :: [GetBotAliases] -> ShowS
show :: GetBotAliases -> String
$cshow :: GetBotAliases -> String
showsPrec :: Int -> GetBotAliases -> ShowS
$cshowsPrec :: Int -> GetBotAliases -> ShowS
Prelude.Show, forall x. Rep GetBotAliases x -> GetBotAliases
forall x. GetBotAliases -> Rep GetBotAliases x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetBotAliases x -> GetBotAliases
$cfrom :: forall x. GetBotAliases -> Rep GetBotAliases x
Prelude.Generic)

-- |
-- Create a value of 'GetBotAliases' 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', 'getBotAliases_maxResults' - The maximum number of aliases to return in the response. The default is
-- 50. .
--
-- 'nameContains', 'getBotAliases_nameContains' - Substring to match in bot alias names. An alias will be returned if any
-- part of its name matches the substring. For example, \"xyz\" matches
-- both \"xyzabc\" and \"abcxyz.\"
--
-- 'nextToken', 'getBotAliases_nextToken' - A pagination token for fetching the next page of aliases. If the
-- response to this call is truncated, Amazon Lex returns a pagination
-- token in the response. To fetch the next page of aliases, specify the
-- pagination token in the next request.
--
-- 'botName', 'getBotAliases_botName' - The name of the bot.
newGetBotAliases ::
  -- | 'botName'
  Prelude.Text ->
  GetBotAliases
newGetBotAliases :: Text -> GetBotAliases
newGetBotAliases Text
pBotName_ =
  GetBotAliases'
    { $sel:maxResults:GetBotAliases' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nameContains:GetBotAliases' :: Maybe Text
nameContains = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:GetBotAliases' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:botName:GetBotAliases' :: Text
botName = Text
pBotName_
    }

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

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

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

-- | The name of the bot.
getBotAliases_botName :: Lens.Lens' GetBotAliases Prelude.Text
getBotAliases_botName :: Lens' GetBotAliases Text
getBotAliases_botName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetBotAliases' {Text
botName :: Text
$sel:botName:GetBotAliases' :: GetBotAliases -> Text
botName} -> Text
botName) (\s :: GetBotAliases
s@GetBotAliases' {} Text
a -> GetBotAliases
s {$sel:botName:GetBotAliases' :: Text
botName = Text
a} :: GetBotAliases)

instance Core.AWSPager GetBotAliases where
  page :: GetBotAliases -> AWSResponse GetBotAliases -> Maybe GetBotAliases
page GetBotAliases
rq AWSResponse GetBotAliases
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse GetBotAliases
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' GetBotAliasesResponse (Maybe Text)
getBotAliasesResponse_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 GetBotAliases
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' GetBotAliasesResponse (Maybe [BotAliasMetadata])
getBotAliasesResponse_botAliases
            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.$ GetBotAliases
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' GetBotAliases (Maybe Text)
getBotAliases_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse GetBotAliases
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' GetBotAliasesResponse (Maybe Text)
getBotAliasesResponse_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 GetBotAliases where
  type
    AWSResponse GetBotAliases =
      GetBotAliasesResponse
  request :: (Service -> Service) -> GetBotAliases -> Request GetBotAliases
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 GetBotAliases
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse GetBotAliases)))
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 [BotAliasMetadata]
-> Maybe Text -> Int -> GetBotAliasesResponse
GetBotAliasesResponse'
            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
"BotAliases" 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.<*> (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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable GetBotAliases where
  hashWithSalt :: Int -> GetBotAliases -> Int
hashWithSalt Int
_salt GetBotAliases' {Maybe Natural
Maybe Text
Text
botName :: Text
nextToken :: Maybe Text
nameContains :: Maybe Text
maxResults :: Maybe Natural
$sel:botName:GetBotAliases' :: GetBotAliases -> Text
$sel:nextToken:GetBotAliases' :: GetBotAliases -> Maybe Text
$sel:nameContains:GetBotAliases' :: GetBotAliases -> Maybe Text
$sel:maxResults:GetBotAliases' :: GetBotAliases -> 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
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
botName

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

instance Data.ToHeaders GetBotAliases where
  toHeaders :: GetBotAliases -> 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 GetBotAliases where
  toPath :: GetBotAliases -> ByteString
toPath GetBotAliases' {Maybe Natural
Maybe Text
Text
botName :: Text
nextToken :: Maybe Text
nameContains :: Maybe Text
maxResults :: Maybe Natural
$sel:botName:GetBotAliases' :: GetBotAliases -> Text
$sel:nextToken:GetBotAliases' :: GetBotAliases -> Maybe Text
$sel:nameContains:GetBotAliases' :: GetBotAliases -> Maybe Text
$sel:maxResults:GetBotAliases' :: GetBotAliases -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/bots/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
botName, ByteString
"/aliases/"]

instance Data.ToQuery GetBotAliases where
  toQuery :: GetBotAliases -> QueryString
toQuery GetBotAliases' {Maybe Natural
Maybe Text
Text
botName :: Text
nextToken :: Maybe Text
nameContains :: Maybe Text
maxResults :: Maybe Natural
$sel:botName:GetBotAliases' :: GetBotAliases -> Text
$sel:nextToken:GetBotAliases' :: GetBotAliases -> Maybe Text
$sel:nameContains:GetBotAliases' :: GetBotAliases -> Maybe Text
$sel:maxResults:GetBotAliases' :: GetBotAliases -> 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:/ 'newGetBotAliasesResponse' smart constructor.
data GetBotAliasesResponse = GetBotAliasesResponse'
  { -- | An array of @BotAliasMetadata@ objects, each describing a bot alias.
    GetBotAliasesResponse -> Maybe [BotAliasMetadata]
botAliases :: Prelude.Maybe [BotAliasMetadata],
    -- | A pagination token for fetching next page of aliases. If the response to
    -- this call is truncated, Amazon Lex returns a pagination token in the
    -- response. To fetch the next page of aliases, specify the pagination
    -- token in the next request.
    GetBotAliasesResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    GetBotAliasesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetBotAliasesResponse -> GetBotAliasesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetBotAliasesResponse -> GetBotAliasesResponse -> Bool
$c/= :: GetBotAliasesResponse -> GetBotAliasesResponse -> Bool
== :: GetBotAliasesResponse -> GetBotAliasesResponse -> Bool
$c== :: GetBotAliasesResponse -> GetBotAliasesResponse -> Bool
Prelude.Eq, ReadPrec [GetBotAliasesResponse]
ReadPrec GetBotAliasesResponse
Int -> ReadS GetBotAliasesResponse
ReadS [GetBotAliasesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetBotAliasesResponse]
$creadListPrec :: ReadPrec [GetBotAliasesResponse]
readPrec :: ReadPrec GetBotAliasesResponse
$creadPrec :: ReadPrec GetBotAliasesResponse
readList :: ReadS [GetBotAliasesResponse]
$creadList :: ReadS [GetBotAliasesResponse]
readsPrec :: Int -> ReadS GetBotAliasesResponse
$creadsPrec :: Int -> ReadS GetBotAliasesResponse
Prelude.Read, Int -> GetBotAliasesResponse -> ShowS
[GetBotAliasesResponse] -> ShowS
GetBotAliasesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetBotAliasesResponse] -> ShowS
$cshowList :: [GetBotAliasesResponse] -> ShowS
show :: GetBotAliasesResponse -> String
$cshow :: GetBotAliasesResponse -> String
showsPrec :: Int -> GetBotAliasesResponse -> ShowS
$cshowsPrec :: Int -> GetBotAliasesResponse -> ShowS
Prelude.Show, forall x. Rep GetBotAliasesResponse x -> GetBotAliasesResponse
forall x. GetBotAliasesResponse -> Rep GetBotAliasesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetBotAliasesResponse x -> GetBotAliasesResponse
$cfrom :: forall x. GetBotAliasesResponse -> Rep GetBotAliasesResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetBotAliasesResponse' 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:
--
-- 'botAliases', 'getBotAliasesResponse_botAliases' - An array of @BotAliasMetadata@ objects, each describing a bot alias.
--
-- 'nextToken', 'getBotAliasesResponse_nextToken' - A pagination token for fetching next page of aliases. If the response to
-- this call is truncated, Amazon Lex returns a pagination token in the
-- response. To fetch the next page of aliases, specify the pagination
-- token in the next request.
--
-- 'httpStatus', 'getBotAliasesResponse_httpStatus' - The response's http status code.
newGetBotAliasesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetBotAliasesResponse
newGetBotAliasesResponse :: Int -> GetBotAliasesResponse
newGetBotAliasesResponse Int
pHttpStatus_ =
  GetBotAliasesResponse'
    { $sel:botAliases:GetBotAliasesResponse' :: Maybe [BotAliasMetadata]
botAliases =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:GetBotAliasesResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetBotAliasesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | An array of @BotAliasMetadata@ objects, each describing a bot alias.
getBotAliasesResponse_botAliases :: Lens.Lens' GetBotAliasesResponse (Prelude.Maybe [BotAliasMetadata])
getBotAliasesResponse_botAliases :: Lens' GetBotAliasesResponse (Maybe [BotAliasMetadata])
getBotAliasesResponse_botAliases = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetBotAliasesResponse' {Maybe [BotAliasMetadata]
botAliases :: Maybe [BotAliasMetadata]
$sel:botAliases:GetBotAliasesResponse' :: GetBotAliasesResponse -> Maybe [BotAliasMetadata]
botAliases} -> Maybe [BotAliasMetadata]
botAliases) (\s :: GetBotAliasesResponse
s@GetBotAliasesResponse' {} Maybe [BotAliasMetadata]
a -> GetBotAliasesResponse
s {$sel:botAliases:GetBotAliasesResponse' :: Maybe [BotAliasMetadata]
botAliases = Maybe [BotAliasMetadata]
a} :: GetBotAliasesResponse) 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

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

-- | The response's http status code.
getBotAliasesResponse_httpStatus :: Lens.Lens' GetBotAliasesResponse Prelude.Int
getBotAliasesResponse_httpStatus :: Lens' GetBotAliasesResponse Int
getBotAliasesResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetBotAliasesResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetBotAliasesResponse' :: GetBotAliasesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetBotAliasesResponse
s@GetBotAliasesResponse' {} Int
a -> GetBotAliasesResponse
s {$sel:httpStatus:GetBotAliasesResponse' :: Int
httpStatus = Int
a} :: GetBotAliasesResponse)

instance Prelude.NFData GetBotAliasesResponse where
  rnf :: GetBotAliasesResponse -> ()
rnf GetBotAliasesResponse' {Int
Maybe [BotAliasMetadata]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
botAliases :: Maybe [BotAliasMetadata]
$sel:httpStatus:GetBotAliasesResponse' :: GetBotAliasesResponse -> Int
$sel:nextToken:GetBotAliasesResponse' :: GetBotAliasesResponse -> Maybe Text
$sel:botAliases:GetBotAliasesResponse' :: GetBotAliasesResponse -> Maybe [BotAliasMetadata]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [BotAliasMetadata]
botAliases
      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 Int
httpStatus