{-# 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.Amplify.ListBackendEnvironments
-- 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 backend environments for an Amplify app.
module Amazonka.Amplify.ListBackendEnvironments
  ( -- * Creating a Request
    ListBackendEnvironments (..),
    newListBackendEnvironments,

    -- * Request Lenses
    listBackendEnvironments_environmentName,
    listBackendEnvironments_maxResults,
    listBackendEnvironments_nextToken,
    listBackendEnvironments_appId,

    -- * Destructuring the Response
    ListBackendEnvironmentsResponse (..),
    newListBackendEnvironmentsResponse,

    -- * Response Lenses
    listBackendEnvironmentsResponse_nextToken,
    listBackendEnvironmentsResponse_httpStatus,
    listBackendEnvironmentsResponse_backendEnvironments,
  )
where

import Amazonka.Amplify.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

-- | The request structure for the list backend environments request.
--
-- /See:/ 'newListBackendEnvironments' smart constructor.
data ListBackendEnvironments = ListBackendEnvironments'
  { -- | The name of the backend environment
    ListBackendEnvironments -> Maybe Text
environmentName :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of records to list in a single response.
    ListBackendEnvironments -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | A pagination token. Set to null to start listing backend environments
    -- from the start. If a non-null pagination token is returned in a result,
    -- pass its value in here to list more backend environments.
    ListBackendEnvironments -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The unique ID for an Amplify app.
    ListBackendEnvironments -> Text
appId :: Prelude.Text
  }
  deriving (ListBackendEnvironments -> ListBackendEnvironments -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListBackendEnvironments -> ListBackendEnvironments -> Bool
$c/= :: ListBackendEnvironments -> ListBackendEnvironments -> Bool
== :: ListBackendEnvironments -> ListBackendEnvironments -> Bool
$c== :: ListBackendEnvironments -> ListBackendEnvironments -> Bool
Prelude.Eq, ReadPrec [ListBackendEnvironments]
ReadPrec ListBackendEnvironments
Int -> ReadS ListBackendEnvironments
ReadS [ListBackendEnvironments]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListBackendEnvironments]
$creadListPrec :: ReadPrec [ListBackendEnvironments]
readPrec :: ReadPrec ListBackendEnvironments
$creadPrec :: ReadPrec ListBackendEnvironments
readList :: ReadS [ListBackendEnvironments]
$creadList :: ReadS [ListBackendEnvironments]
readsPrec :: Int -> ReadS ListBackendEnvironments
$creadsPrec :: Int -> ReadS ListBackendEnvironments
Prelude.Read, Int -> ListBackendEnvironments -> ShowS
[ListBackendEnvironments] -> ShowS
ListBackendEnvironments -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListBackendEnvironments] -> ShowS
$cshowList :: [ListBackendEnvironments] -> ShowS
show :: ListBackendEnvironments -> String
$cshow :: ListBackendEnvironments -> String
showsPrec :: Int -> ListBackendEnvironments -> ShowS
$cshowsPrec :: Int -> ListBackendEnvironments -> ShowS
Prelude.Show, forall x. Rep ListBackendEnvironments x -> ListBackendEnvironments
forall x. ListBackendEnvironments -> Rep ListBackendEnvironments x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListBackendEnvironments x -> ListBackendEnvironments
$cfrom :: forall x. ListBackendEnvironments -> Rep ListBackendEnvironments x
Prelude.Generic)

-- |
-- Create a value of 'ListBackendEnvironments' 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:
--
-- 'environmentName', 'listBackendEnvironments_environmentName' - The name of the backend environment
--
-- 'maxResults', 'listBackendEnvironments_maxResults' - The maximum number of records to list in a single response.
--
-- 'nextToken', 'listBackendEnvironments_nextToken' - A pagination token. Set to null to start listing backend environments
-- from the start. If a non-null pagination token is returned in a result,
-- pass its value in here to list more backend environments.
--
-- 'appId', 'listBackendEnvironments_appId' - The unique ID for an Amplify app.
newListBackendEnvironments ::
  -- | 'appId'
  Prelude.Text ->
  ListBackendEnvironments
newListBackendEnvironments :: Text -> ListBackendEnvironments
newListBackendEnvironments Text
pAppId_ =
  ListBackendEnvironments'
    { $sel:environmentName:ListBackendEnvironments' :: Maybe Text
environmentName =
        forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListBackendEnvironments' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListBackendEnvironments' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:appId:ListBackendEnvironments' :: Text
appId = Text
pAppId_
    }

-- | The name of the backend environment
listBackendEnvironments_environmentName :: Lens.Lens' ListBackendEnvironments (Prelude.Maybe Prelude.Text)
listBackendEnvironments_environmentName :: Lens' ListBackendEnvironments (Maybe Text)
listBackendEnvironments_environmentName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBackendEnvironments' {Maybe Text
environmentName :: Maybe Text
$sel:environmentName:ListBackendEnvironments' :: ListBackendEnvironments -> Maybe Text
environmentName} -> Maybe Text
environmentName) (\s :: ListBackendEnvironments
s@ListBackendEnvironments' {} Maybe Text
a -> ListBackendEnvironments
s {$sel:environmentName:ListBackendEnvironments' :: Maybe Text
environmentName = Maybe Text
a} :: ListBackendEnvironments)

-- | The maximum number of records to list in a single response.
listBackendEnvironments_maxResults :: Lens.Lens' ListBackendEnvironments (Prelude.Maybe Prelude.Natural)
listBackendEnvironments_maxResults :: Lens' ListBackendEnvironments (Maybe Natural)
listBackendEnvironments_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBackendEnvironments' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListBackendEnvironments' :: ListBackendEnvironments -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListBackendEnvironments
s@ListBackendEnvironments' {} Maybe Natural
a -> ListBackendEnvironments
s {$sel:maxResults:ListBackendEnvironments' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListBackendEnvironments)

-- | A pagination token. Set to null to start listing backend environments
-- from the start. If a non-null pagination token is returned in a result,
-- pass its value in here to list more backend environments.
listBackendEnvironments_nextToken :: Lens.Lens' ListBackendEnvironments (Prelude.Maybe Prelude.Text)
listBackendEnvironments_nextToken :: Lens' ListBackendEnvironments (Maybe Text)
listBackendEnvironments_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBackendEnvironments' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListBackendEnvironments' :: ListBackendEnvironments -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListBackendEnvironments
s@ListBackendEnvironments' {} Maybe Text
a -> ListBackendEnvironments
s {$sel:nextToken:ListBackendEnvironments' :: Maybe Text
nextToken = Maybe Text
a} :: ListBackendEnvironments)

-- | The unique ID for an Amplify app.
listBackendEnvironments_appId :: Lens.Lens' ListBackendEnvironments Prelude.Text
listBackendEnvironments_appId :: Lens' ListBackendEnvironments Text
listBackendEnvironments_appId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBackendEnvironments' {Text
appId :: Text
$sel:appId:ListBackendEnvironments' :: ListBackendEnvironments -> Text
appId} -> Text
appId) (\s :: ListBackendEnvironments
s@ListBackendEnvironments' {} Text
a -> ListBackendEnvironments
s {$sel:appId:ListBackendEnvironments' :: Text
appId = Text
a} :: ListBackendEnvironments)

instance Core.AWSRequest ListBackendEnvironments where
  type
    AWSResponse ListBackendEnvironments =
      ListBackendEnvironmentsResponse
  request :: (Service -> Service)
-> ListBackendEnvironments -> Request ListBackendEnvironments
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 ListBackendEnvironments
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListBackendEnvironments)))
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
-> Int -> [BackendEnvironment] -> ListBackendEnvironmentsResponse
ListBackendEnvironmentsResponse'
            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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            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
"backendEnvironments"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable ListBackendEnvironments where
  hashWithSalt :: Int -> ListBackendEnvironments -> Int
hashWithSalt Int
_salt ListBackendEnvironments' {Maybe Natural
Maybe Text
Text
appId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
environmentName :: Maybe Text
$sel:appId:ListBackendEnvironments' :: ListBackendEnvironments -> Text
$sel:nextToken:ListBackendEnvironments' :: ListBackendEnvironments -> Maybe Text
$sel:maxResults:ListBackendEnvironments' :: ListBackendEnvironments -> Maybe Natural
$sel:environmentName:ListBackendEnvironments' :: ListBackendEnvironments -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
environmentName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
appId

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

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

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

-- | The result structure for the list backend environments result.
--
-- /See:/ 'newListBackendEnvironmentsResponse' smart constructor.
data ListBackendEnvironmentsResponse = ListBackendEnvironmentsResponse'
  { -- | A pagination token. If a non-null pagination token is returned in a
    -- result, pass its value in another request to retrieve more entries.
    ListBackendEnvironmentsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListBackendEnvironmentsResponse -> Int
httpStatus :: Prelude.Int,
    -- | The list of backend environments for an Amplify app.
    ListBackendEnvironmentsResponse -> [BackendEnvironment]
backendEnvironments :: [BackendEnvironment]
  }
  deriving (ListBackendEnvironmentsResponse
-> ListBackendEnvironmentsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListBackendEnvironmentsResponse
-> ListBackendEnvironmentsResponse -> Bool
$c/= :: ListBackendEnvironmentsResponse
-> ListBackendEnvironmentsResponse -> Bool
== :: ListBackendEnvironmentsResponse
-> ListBackendEnvironmentsResponse -> Bool
$c== :: ListBackendEnvironmentsResponse
-> ListBackendEnvironmentsResponse -> Bool
Prelude.Eq, ReadPrec [ListBackendEnvironmentsResponse]
ReadPrec ListBackendEnvironmentsResponse
Int -> ReadS ListBackendEnvironmentsResponse
ReadS [ListBackendEnvironmentsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListBackendEnvironmentsResponse]
$creadListPrec :: ReadPrec [ListBackendEnvironmentsResponse]
readPrec :: ReadPrec ListBackendEnvironmentsResponse
$creadPrec :: ReadPrec ListBackendEnvironmentsResponse
readList :: ReadS [ListBackendEnvironmentsResponse]
$creadList :: ReadS [ListBackendEnvironmentsResponse]
readsPrec :: Int -> ReadS ListBackendEnvironmentsResponse
$creadsPrec :: Int -> ReadS ListBackendEnvironmentsResponse
Prelude.Read, Int -> ListBackendEnvironmentsResponse -> ShowS
[ListBackendEnvironmentsResponse] -> ShowS
ListBackendEnvironmentsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListBackendEnvironmentsResponse] -> ShowS
$cshowList :: [ListBackendEnvironmentsResponse] -> ShowS
show :: ListBackendEnvironmentsResponse -> String
$cshow :: ListBackendEnvironmentsResponse -> String
showsPrec :: Int -> ListBackendEnvironmentsResponse -> ShowS
$cshowsPrec :: Int -> ListBackendEnvironmentsResponse -> ShowS
Prelude.Show, forall x.
Rep ListBackendEnvironmentsResponse x
-> ListBackendEnvironmentsResponse
forall x.
ListBackendEnvironmentsResponse
-> Rep ListBackendEnvironmentsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListBackendEnvironmentsResponse x
-> ListBackendEnvironmentsResponse
$cfrom :: forall x.
ListBackendEnvironmentsResponse
-> Rep ListBackendEnvironmentsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListBackendEnvironmentsResponse' 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', 'listBackendEnvironmentsResponse_nextToken' - A pagination token. If a non-null pagination token is returned in a
-- result, pass its value in another request to retrieve more entries.
--
-- 'httpStatus', 'listBackendEnvironmentsResponse_httpStatus' - The response's http status code.
--
-- 'backendEnvironments', 'listBackendEnvironmentsResponse_backendEnvironments' - The list of backend environments for an Amplify app.
newListBackendEnvironmentsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListBackendEnvironmentsResponse
newListBackendEnvironmentsResponse :: Int -> ListBackendEnvironmentsResponse
newListBackendEnvironmentsResponse Int
pHttpStatus_ =
  ListBackendEnvironmentsResponse'
    { $sel:nextToken:ListBackendEnvironmentsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListBackendEnvironmentsResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:backendEnvironments:ListBackendEnvironmentsResponse' :: [BackendEnvironment]
backendEnvironments = forall a. Monoid a => a
Prelude.mempty
    }

-- | A pagination token. If a non-null pagination token is returned in a
-- result, pass its value in another request to retrieve more entries.
listBackendEnvironmentsResponse_nextToken :: Lens.Lens' ListBackendEnvironmentsResponse (Prelude.Maybe Prelude.Text)
listBackendEnvironmentsResponse_nextToken :: Lens' ListBackendEnvironmentsResponse (Maybe Text)
listBackendEnvironmentsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBackendEnvironmentsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListBackendEnvironmentsResponse' :: ListBackendEnvironmentsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListBackendEnvironmentsResponse
s@ListBackendEnvironmentsResponse' {} Maybe Text
a -> ListBackendEnvironmentsResponse
s {$sel:nextToken:ListBackendEnvironmentsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListBackendEnvironmentsResponse)

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

-- | The list of backend environments for an Amplify app.
listBackendEnvironmentsResponse_backendEnvironments :: Lens.Lens' ListBackendEnvironmentsResponse [BackendEnvironment]
listBackendEnvironmentsResponse_backendEnvironments :: Lens' ListBackendEnvironmentsResponse [BackendEnvironment]
listBackendEnvironmentsResponse_backendEnvironments = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListBackendEnvironmentsResponse' {[BackendEnvironment]
backendEnvironments :: [BackendEnvironment]
$sel:backendEnvironments:ListBackendEnvironmentsResponse' :: ListBackendEnvironmentsResponse -> [BackendEnvironment]
backendEnvironments} -> [BackendEnvironment]
backendEnvironments) (\s :: ListBackendEnvironmentsResponse
s@ListBackendEnvironmentsResponse' {} [BackendEnvironment]
a -> ListBackendEnvironmentsResponse
s {$sel:backendEnvironments:ListBackendEnvironmentsResponse' :: [BackendEnvironment]
backendEnvironments = [BackendEnvironment]
a} :: ListBackendEnvironmentsResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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