{-# 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.DrS.ListExtensibleSourceServers
-- 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 source servers on a staging account that are
-- extensible, which means that: a. The source server is not already
-- extended into this Account. b. The source server on the Account we’re
-- reading from is not an extension of another source server.
--
-- This operation returns paginated results.
module Amazonka.DrS.ListExtensibleSourceServers
  ( -- * Creating a Request
    ListExtensibleSourceServers (..),
    newListExtensibleSourceServers,

    -- * Request Lenses
    listExtensibleSourceServers_maxResults,
    listExtensibleSourceServers_nextToken,
    listExtensibleSourceServers_stagingAccountID,

    -- * Destructuring the Response
    ListExtensibleSourceServersResponse (..),
    newListExtensibleSourceServersResponse,

    -- * Response Lenses
    listExtensibleSourceServersResponse_items,
    listExtensibleSourceServersResponse_nextToken,
    listExtensibleSourceServersResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListExtensibleSourceServers' smart constructor.
data ListExtensibleSourceServers = ListExtensibleSourceServers'
  { -- | The maximum number of extensible source servers to retrieve.
    ListExtensibleSourceServers -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token of the next extensible source server to retrieve.
    ListExtensibleSourceServers -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The Id of the staging Account to retrieve extensible source servers
    -- from.
    ListExtensibleSourceServers -> Text
stagingAccountID :: Prelude.Text
  }
  deriving (ListExtensibleSourceServers -> ListExtensibleSourceServers -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListExtensibleSourceServers -> ListExtensibleSourceServers -> Bool
$c/= :: ListExtensibleSourceServers -> ListExtensibleSourceServers -> Bool
== :: ListExtensibleSourceServers -> ListExtensibleSourceServers -> Bool
$c== :: ListExtensibleSourceServers -> ListExtensibleSourceServers -> Bool
Prelude.Eq, ReadPrec [ListExtensibleSourceServers]
ReadPrec ListExtensibleSourceServers
Int -> ReadS ListExtensibleSourceServers
ReadS [ListExtensibleSourceServers]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListExtensibleSourceServers]
$creadListPrec :: ReadPrec [ListExtensibleSourceServers]
readPrec :: ReadPrec ListExtensibleSourceServers
$creadPrec :: ReadPrec ListExtensibleSourceServers
readList :: ReadS [ListExtensibleSourceServers]
$creadList :: ReadS [ListExtensibleSourceServers]
readsPrec :: Int -> ReadS ListExtensibleSourceServers
$creadsPrec :: Int -> ReadS ListExtensibleSourceServers
Prelude.Read, Int -> ListExtensibleSourceServers -> ShowS
[ListExtensibleSourceServers] -> ShowS
ListExtensibleSourceServers -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListExtensibleSourceServers] -> ShowS
$cshowList :: [ListExtensibleSourceServers] -> ShowS
show :: ListExtensibleSourceServers -> String
$cshow :: ListExtensibleSourceServers -> String
showsPrec :: Int -> ListExtensibleSourceServers -> ShowS
$cshowsPrec :: Int -> ListExtensibleSourceServers -> ShowS
Prelude.Show, forall x.
Rep ListExtensibleSourceServers x -> ListExtensibleSourceServers
forall x.
ListExtensibleSourceServers -> Rep ListExtensibleSourceServers x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListExtensibleSourceServers x -> ListExtensibleSourceServers
$cfrom :: forall x.
ListExtensibleSourceServers -> Rep ListExtensibleSourceServers x
Prelude.Generic)

-- |
-- Create a value of 'ListExtensibleSourceServers' 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', 'listExtensibleSourceServers_maxResults' - The maximum number of extensible source servers to retrieve.
--
-- 'nextToken', 'listExtensibleSourceServers_nextToken' - The token of the next extensible source server to retrieve.
--
-- 'stagingAccountID', 'listExtensibleSourceServers_stagingAccountID' - The Id of the staging Account to retrieve extensible source servers
-- from.
newListExtensibleSourceServers ::
  -- | 'stagingAccountID'
  Prelude.Text ->
  ListExtensibleSourceServers
newListExtensibleSourceServers :: Text -> ListExtensibleSourceServers
newListExtensibleSourceServers Text
pStagingAccountID_ =
  ListExtensibleSourceServers'
    { $sel:maxResults:ListExtensibleSourceServers' :: Maybe Natural
maxResults =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListExtensibleSourceServers' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:stagingAccountID:ListExtensibleSourceServers' :: Text
stagingAccountID = Text
pStagingAccountID_
    }

-- | The maximum number of extensible source servers to retrieve.
listExtensibleSourceServers_maxResults :: Lens.Lens' ListExtensibleSourceServers (Prelude.Maybe Prelude.Natural)
listExtensibleSourceServers_maxResults :: Lens' ListExtensibleSourceServers (Maybe Natural)
listExtensibleSourceServers_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListExtensibleSourceServers' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListExtensibleSourceServers
s@ListExtensibleSourceServers' {} Maybe Natural
a -> ListExtensibleSourceServers
s {$sel:maxResults:ListExtensibleSourceServers' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListExtensibleSourceServers)

-- | The token of the next extensible source server to retrieve.
listExtensibleSourceServers_nextToken :: Lens.Lens' ListExtensibleSourceServers (Prelude.Maybe Prelude.Text)
listExtensibleSourceServers_nextToken :: Lens' ListExtensibleSourceServers (Maybe Text)
listExtensibleSourceServers_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListExtensibleSourceServers' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListExtensibleSourceServers
s@ListExtensibleSourceServers' {} Maybe Text
a -> ListExtensibleSourceServers
s {$sel:nextToken:ListExtensibleSourceServers' :: Maybe Text
nextToken = Maybe Text
a} :: ListExtensibleSourceServers)

-- | The Id of the staging Account to retrieve extensible source servers
-- from.
listExtensibleSourceServers_stagingAccountID :: Lens.Lens' ListExtensibleSourceServers Prelude.Text
listExtensibleSourceServers_stagingAccountID :: Lens' ListExtensibleSourceServers Text
listExtensibleSourceServers_stagingAccountID = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListExtensibleSourceServers' {Text
stagingAccountID :: Text
$sel:stagingAccountID:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Text
stagingAccountID} -> Text
stagingAccountID) (\s :: ListExtensibleSourceServers
s@ListExtensibleSourceServers' {} Text
a -> ListExtensibleSourceServers
s {$sel:stagingAccountID:ListExtensibleSourceServers' :: Text
stagingAccountID = Text
a} :: ListExtensibleSourceServers)

instance Core.AWSPager ListExtensibleSourceServers where
  page :: ListExtensibleSourceServers
-> AWSResponse ListExtensibleSourceServers
-> Maybe ListExtensibleSourceServers
page ListExtensibleSourceServers
rq AWSResponse ListExtensibleSourceServers
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListExtensibleSourceServers
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListExtensibleSourceServersResponse (Maybe Text)
listExtensibleSourceServersResponse_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 ListExtensibleSourceServers
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListExtensibleSourceServersResponse (Maybe [StagingSourceServer])
listExtensibleSourceServersResponse_items
            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.$ ListExtensibleSourceServers
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListExtensibleSourceServers (Maybe Text)
listExtensibleSourceServers_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListExtensibleSourceServers
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListExtensibleSourceServersResponse (Maybe Text)
listExtensibleSourceServersResponse_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 ListExtensibleSourceServers where
  type
    AWSResponse ListExtensibleSourceServers =
      ListExtensibleSourceServersResponse
  request :: (Service -> Service)
-> ListExtensibleSourceServers
-> Request ListExtensibleSourceServers
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListExtensibleSourceServers
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListExtensibleSourceServers)))
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 [StagingSourceServer]
-> Maybe Text -> Int -> ListExtensibleSourceServersResponse
ListExtensibleSourceServersResponse'
            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
"items" 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 ListExtensibleSourceServers where
  hashWithSalt :: Int -> ListExtensibleSourceServers -> Int
hashWithSalt Int
_salt ListExtensibleSourceServers' {Maybe Natural
Maybe Text
Text
stagingAccountID :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:stagingAccountID:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Text
$sel:nextToken:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Maybe Text
$sel:maxResults:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> 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
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
stagingAccountID

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

instance Data.ToHeaders ListExtensibleSourceServers where
  toHeaders :: ListExtensibleSourceServers -> 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.ToJSON ListExtensibleSourceServers where
  toJSON :: ListExtensibleSourceServers -> Value
toJSON ListExtensibleSourceServers' {Maybe Natural
Maybe Text
Text
stagingAccountID :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:stagingAccountID:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Text
$sel:nextToken:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Maybe Text
$sel:maxResults:ListExtensibleSourceServers' :: ListExtensibleSourceServers -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"maxResults" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxResults,
            (Key
"nextToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextToken,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"stagingAccountID" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
stagingAccountID)
          ]
      )

instance Data.ToPath ListExtensibleSourceServers where
  toPath :: ListExtensibleSourceServers -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/ListExtensibleSourceServers"

instance Data.ToQuery ListExtensibleSourceServers where
  toQuery :: ListExtensibleSourceServers -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newListExtensibleSourceServersResponse' smart constructor.
data ListExtensibleSourceServersResponse = ListExtensibleSourceServersResponse'
  { -- | A list of source servers on a staging Account that are extensible.
    ListExtensibleSourceServersResponse -> Maybe [StagingSourceServer]
items :: Prelude.Maybe [StagingSourceServer],
    -- | The token of the next extensible source server to retrieve.
    ListExtensibleSourceServersResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListExtensibleSourceServersResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListExtensibleSourceServersResponse
-> ListExtensibleSourceServersResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListExtensibleSourceServersResponse
-> ListExtensibleSourceServersResponse -> Bool
$c/= :: ListExtensibleSourceServersResponse
-> ListExtensibleSourceServersResponse -> Bool
== :: ListExtensibleSourceServersResponse
-> ListExtensibleSourceServersResponse -> Bool
$c== :: ListExtensibleSourceServersResponse
-> ListExtensibleSourceServersResponse -> Bool
Prelude.Eq, Int -> ListExtensibleSourceServersResponse -> ShowS
[ListExtensibleSourceServersResponse] -> ShowS
ListExtensibleSourceServersResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListExtensibleSourceServersResponse] -> ShowS
$cshowList :: [ListExtensibleSourceServersResponse] -> ShowS
show :: ListExtensibleSourceServersResponse -> String
$cshow :: ListExtensibleSourceServersResponse -> String
showsPrec :: Int -> ListExtensibleSourceServersResponse -> ShowS
$cshowsPrec :: Int -> ListExtensibleSourceServersResponse -> ShowS
Prelude.Show, forall x.
Rep ListExtensibleSourceServersResponse x
-> ListExtensibleSourceServersResponse
forall x.
ListExtensibleSourceServersResponse
-> Rep ListExtensibleSourceServersResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListExtensibleSourceServersResponse x
-> ListExtensibleSourceServersResponse
$cfrom :: forall x.
ListExtensibleSourceServersResponse
-> Rep ListExtensibleSourceServersResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListExtensibleSourceServersResponse' 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:
--
-- 'items', 'listExtensibleSourceServersResponse_items' - A list of source servers on a staging Account that are extensible.
--
-- 'nextToken', 'listExtensibleSourceServersResponse_nextToken' - The token of the next extensible source server to retrieve.
--
-- 'httpStatus', 'listExtensibleSourceServersResponse_httpStatus' - The response's http status code.
newListExtensibleSourceServersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListExtensibleSourceServersResponse
newListExtensibleSourceServersResponse :: Int -> ListExtensibleSourceServersResponse
newListExtensibleSourceServersResponse Int
pHttpStatus_ =
  ListExtensibleSourceServersResponse'
    { $sel:items:ListExtensibleSourceServersResponse' :: Maybe [StagingSourceServer]
items =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListExtensibleSourceServersResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListExtensibleSourceServersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of source servers on a staging Account that are extensible.
listExtensibleSourceServersResponse_items :: Lens.Lens' ListExtensibleSourceServersResponse (Prelude.Maybe [StagingSourceServer])
listExtensibleSourceServersResponse_items :: Lens'
  ListExtensibleSourceServersResponse (Maybe [StagingSourceServer])
listExtensibleSourceServersResponse_items = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListExtensibleSourceServersResponse' {Maybe [StagingSourceServer]
items :: Maybe [StagingSourceServer]
$sel:items:ListExtensibleSourceServersResponse' :: ListExtensibleSourceServersResponse -> Maybe [StagingSourceServer]
items} -> Maybe [StagingSourceServer]
items) (\s :: ListExtensibleSourceServersResponse
s@ListExtensibleSourceServersResponse' {} Maybe [StagingSourceServer]
a -> ListExtensibleSourceServersResponse
s {$sel:items:ListExtensibleSourceServersResponse' :: Maybe [StagingSourceServer]
items = Maybe [StagingSourceServer]
a} :: ListExtensibleSourceServersResponse) 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 token of the next extensible source server to retrieve.
listExtensibleSourceServersResponse_nextToken :: Lens.Lens' ListExtensibleSourceServersResponse (Prelude.Maybe Prelude.Text)
listExtensibleSourceServersResponse_nextToken :: Lens' ListExtensibleSourceServersResponse (Maybe Text)
listExtensibleSourceServersResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListExtensibleSourceServersResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListExtensibleSourceServersResponse' :: ListExtensibleSourceServersResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListExtensibleSourceServersResponse
s@ListExtensibleSourceServersResponse' {} Maybe Text
a -> ListExtensibleSourceServersResponse
s {$sel:nextToken:ListExtensibleSourceServersResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListExtensibleSourceServersResponse)

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

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