{-# 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.MigrationHub.ListProgressUpdateStreams
-- 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 progress update streams associated with the user account making
-- this call.
--
-- This operation returns paginated results.
module Amazonka.MigrationHub.ListProgressUpdateStreams
  ( -- * Creating a Request
    ListProgressUpdateStreams (..),
    newListProgressUpdateStreams,

    -- * Request Lenses
    listProgressUpdateStreams_maxResults,
    listProgressUpdateStreams_nextToken,

    -- * Destructuring the Response
    ListProgressUpdateStreamsResponse (..),
    newListProgressUpdateStreamsResponse,

    -- * Response Lenses
    listProgressUpdateStreamsResponse_nextToken,
    listProgressUpdateStreamsResponse_progressUpdateStreamSummaryList,
    listProgressUpdateStreamsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListProgressUpdateStreams' smart constructor.
data ListProgressUpdateStreams = ListProgressUpdateStreams'
  { -- | Filter to limit the maximum number of results to list per page.
    ListProgressUpdateStreams -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | If a @NextToken@ was returned by a previous call, there are more results
    -- available. To retrieve the next page of results, make the call again
    -- using the returned token in @NextToken@.
    ListProgressUpdateStreams -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (ListProgressUpdateStreams -> ListProgressUpdateStreams -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListProgressUpdateStreams -> ListProgressUpdateStreams -> Bool
$c/= :: ListProgressUpdateStreams -> ListProgressUpdateStreams -> Bool
== :: ListProgressUpdateStreams -> ListProgressUpdateStreams -> Bool
$c== :: ListProgressUpdateStreams -> ListProgressUpdateStreams -> Bool
Prelude.Eq, ReadPrec [ListProgressUpdateStreams]
ReadPrec ListProgressUpdateStreams
Int -> ReadS ListProgressUpdateStreams
ReadS [ListProgressUpdateStreams]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListProgressUpdateStreams]
$creadListPrec :: ReadPrec [ListProgressUpdateStreams]
readPrec :: ReadPrec ListProgressUpdateStreams
$creadPrec :: ReadPrec ListProgressUpdateStreams
readList :: ReadS [ListProgressUpdateStreams]
$creadList :: ReadS [ListProgressUpdateStreams]
readsPrec :: Int -> ReadS ListProgressUpdateStreams
$creadsPrec :: Int -> ReadS ListProgressUpdateStreams
Prelude.Read, Int -> ListProgressUpdateStreams -> ShowS
[ListProgressUpdateStreams] -> ShowS
ListProgressUpdateStreams -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListProgressUpdateStreams] -> ShowS
$cshowList :: [ListProgressUpdateStreams] -> ShowS
show :: ListProgressUpdateStreams -> String
$cshow :: ListProgressUpdateStreams -> String
showsPrec :: Int -> ListProgressUpdateStreams -> ShowS
$cshowsPrec :: Int -> ListProgressUpdateStreams -> ShowS
Prelude.Show, forall x.
Rep ListProgressUpdateStreams x -> ListProgressUpdateStreams
forall x.
ListProgressUpdateStreams -> Rep ListProgressUpdateStreams x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListProgressUpdateStreams x -> ListProgressUpdateStreams
$cfrom :: forall x.
ListProgressUpdateStreams -> Rep ListProgressUpdateStreams x
Prelude.Generic)

-- |
-- Create a value of 'ListProgressUpdateStreams' 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', 'listProgressUpdateStreams_maxResults' - Filter to limit the maximum number of results to list per page.
--
-- 'nextToken', 'listProgressUpdateStreams_nextToken' - If a @NextToken@ was returned by a previous call, there are more results
-- available. To retrieve the next page of results, make the call again
-- using the returned token in @NextToken@.
newListProgressUpdateStreams ::
  ListProgressUpdateStreams
newListProgressUpdateStreams :: ListProgressUpdateStreams
newListProgressUpdateStreams =
  ListProgressUpdateStreams'
    { $sel:maxResults:ListProgressUpdateStreams' :: Maybe Natural
maxResults =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListProgressUpdateStreams' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | Filter to limit the maximum number of results to list per page.
listProgressUpdateStreams_maxResults :: Lens.Lens' ListProgressUpdateStreams (Prelude.Maybe Prelude.Natural)
listProgressUpdateStreams_maxResults :: Lens' ListProgressUpdateStreams (Maybe Natural)
listProgressUpdateStreams_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProgressUpdateStreams' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListProgressUpdateStreams
s@ListProgressUpdateStreams' {} Maybe Natural
a -> ListProgressUpdateStreams
s {$sel:maxResults:ListProgressUpdateStreams' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListProgressUpdateStreams)

-- | If a @NextToken@ was returned by a previous call, there are more results
-- available. To retrieve the next page of results, make the call again
-- using the returned token in @NextToken@.
listProgressUpdateStreams_nextToken :: Lens.Lens' ListProgressUpdateStreams (Prelude.Maybe Prelude.Text)
listProgressUpdateStreams_nextToken :: Lens' ListProgressUpdateStreams (Maybe Text)
listProgressUpdateStreams_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProgressUpdateStreams' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListProgressUpdateStreams
s@ListProgressUpdateStreams' {} Maybe Text
a -> ListProgressUpdateStreams
s {$sel:nextToken:ListProgressUpdateStreams' :: Maybe Text
nextToken = Maybe Text
a} :: ListProgressUpdateStreams)

instance Core.AWSPager ListProgressUpdateStreams where
  page :: ListProgressUpdateStreams
-> AWSResponse ListProgressUpdateStreams
-> Maybe ListProgressUpdateStreams
page ListProgressUpdateStreams
rq AWSResponse ListProgressUpdateStreams
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListProgressUpdateStreams
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListProgressUpdateStreamsResponse (Maybe Text)
listProgressUpdateStreamsResponse_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 ListProgressUpdateStreams
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListProgressUpdateStreamsResponse
  (Maybe [ProgressUpdateStreamSummary])
listProgressUpdateStreamsResponse_progressUpdateStreamSummaryList
            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.$ ListProgressUpdateStreams
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListProgressUpdateStreams (Maybe Text)
listProgressUpdateStreams_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListProgressUpdateStreams
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListProgressUpdateStreamsResponse (Maybe Text)
listProgressUpdateStreamsResponse_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 ListProgressUpdateStreams where
  type
    AWSResponse ListProgressUpdateStreams =
      ListProgressUpdateStreamsResponse
  request :: (Service -> Service)
-> ListProgressUpdateStreams -> Request ListProgressUpdateStreams
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 ListProgressUpdateStreams
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListProgressUpdateStreams)))
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 [ProgressUpdateStreamSummary]
-> Int
-> ListProgressUpdateStreamsResponse
ListProgressUpdateStreamsResponse'
            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
"ProgressUpdateStreamSummaryList"
                            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 ListProgressUpdateStreams where
  hashWithSalt :: Int -> ListProgressUpdateStreams -> Int
hashWithSalt Int
_salt ListProgressUpdateStreams' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> Maybe Text
$sel:maxResults:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> 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

instance Prelude.NFData ListProgressUpdateStreams where
  rnf :: ListProgressUpdateStreams -> ()
rnf ListProgressUpdateStreams' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> Maybe Text
$sel:maxResults:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> 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

instance Data.ToHeaders ListProgressUpdateStreams where
  toHeaders :: ListProgressUpdateStreams -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AWSMigrationHub.ListProgressUpdateStreams" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON ListProgressUpdateStreams where
  toJSON :: ListProgressUpdateStreams -> Value
toJSON ListProgressUpdateStreams' {Maybe Natural
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
$sel:nextToken:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> Maybe Text
$sel:maxResults:ListProgressUpdateStreams' :: ListProgressUpdateStreams -> 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
          ]
      )

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

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

-- | /See:/ 'newListProgressUpdateStreamsResponse' smart constructor.
data ListProgressUpdateStreamsResponse = ListProgressUpdateStreamsResponse'
  { -- | If there are more streams created than the max result, return the next
    -- token to be passed to the next call as a bookmark of where to start
    -- from.
    ListProgressUpdateStreamsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | List of progress update streams up to the max number of results passed
    -- in the input.
    ListProgressUpdateStreamsResponse
-> Maybe [ProgressUpdateStreamSummary]
progressUpdateStreamSummaryList :: Prelude.Maybe [ProgressUpdateStreamSummary],
    -- | The response's http status code.
    ListProgressUpdateStreamsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListProgressUpdateStreamsResponse
-> ListProgressUpdateStreamsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListProgressUpdateStreamsResponse
-> ListProgressUpdateStreamsResponse -> Bool
$c/= :: ListProgressUpdateStreamsResponse
-> ListProgressUpdateStreamsResponse -> Bool
== :: ListProgressUpdateStreamsResponse
-> ListProgressUpdateStreamsResponse -> Bool
$c== :: ListProgressUpdateStreamsResponse
-> ListProgressUpdateStreamsResponse -> Bool
Prelude.Eq, ReadPrec [ListProgressUpdateStreamsResponse]
ReadPrec ListProgressUpdateStreamsResponse
Int -> ReadS ListProgressUpdateStreamsResponse
ReadS [ListProgressUpdateStreamsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListProgressUpdateStreamsResponse]
$creadListPrec :: ReadPrec [ListProgressUpdateStreamsResponse]
readPrec :: ReadPrec ListProgressUpdateStreamsResponse
$creadPrec :: ReadPrec ListProgressUpdateStreamsResponse
readList :: ReadS [ListProgressUpdateStreamsResponse]
$creadList :: ReadS [ListProgressUpdateStreamsResponse]
readsPrec :: Int -> ReadS ListProgressUpdateStreamsResponse
$creadsPrec :: Int -> ReadS ListProgressUpdateStreamsResponse
Prelude.Read, Int -> ListProgressUpdateStreamsResponse -> ShowS
[ListProgressUpdateStreamsResponse] -> ShowS
ListProgressUpdateStreamsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListProgressUpdateStreamsResponse] -> ShowS
$cshowList :: [ListProgressUpdateStreamsResponse] -> ShowS
show :: ListProgressUpdateStreamsResponse -> String
$cshow :: ListProgressUpdateStreamsResponse -> String
showsPrec :: Int -> ListProgressUpdateStreamsResponse -> ShowS
$cshowsPrec :: Int -> ListProgressUpdateStreamsResponse -> ShowS
Prelude.Show, forall x.
Rep ListProgressUpdateStreamsResponse x
-> ListProgressUpdateStreamsResponse
forall x.
ListProgressUpdateStreamsResponse
-> Rep ListProgressUpdateStreamsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListProgressUpdateStreamsResponse x
-> ListProgressUpdateStreamsResponse
$cfrom :: forall x.
ListProgressUpdateStreamsResponse
-> Rep ListProgressUpdateStreamsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListProgressUpdateStreamsResponse' 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', 'listProgressUpdateStreamsResponse_nextToken' - If there are more streams created than the max result, return the next
-- token to be passed to the next call as a bookmark of where to start
-- from.
--
-- 'progressUpdateStreamSummaryList', 'listProgressUpdateStreamsResponse_progressUpdateStreamSummaryList' - List of progress update streams up to the max number of results passed
-- in the input.
--
-- 'httpStatus', 'listProgressUpdateStreamsResponse_httpStatus' - The response's http status code.
newListProgressUpdateStreamsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListProgressUpdateStreamsResponse
newListProgressUpdateStreamsResponse :: Int -> ListProgressUpdateStreamsResponse
newListProgressUpdateStreamsResponse Int
pHttpStatus_ =
  ListProgressUpdateStreamsResponse'
    { $sel:nextToken:ListProgressUpdateStreamsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:progressUpdateStreamSummaryList:ListProgressUpdateStreamsResponse' :: Maybe [ProgressUpdateStreamSummary]
progressUpdateStreamSummaryList =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListProgressUpdateStreamsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | If there are more streams created than the max result, return the next
-- token to be passed to the next call as a bookmark of where to start
-- from.
listProgressUpdateStreamsResponse_nextToken :: Lens.Lens' ListProgressUpdateStreamsResponse (Prelude.Maybe Prelude.Text)
listProgressUpdateStreamsResponse_nextToken :: Lens' ListProgressUpdateStreamsResponse (Maybe Text)
listProgressUpdateStreamsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProgressUpdateStreamsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListProgressUpdateStreamsResponse' :: ListProgressUpdateStreamsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListProgressUpdateStreamsResponse
s@ListProgressUpdateStreamsResponse' {} Maybe Text
a -> ListProgressUpdateStreamsResponse
s {$sel:nextToken:ListProgressUpdateStreamsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListProgressUpdateStreamsResponse)

-- | List of progress update streams up to the max number of results passed
-- in the input.
listProgressUpdateStreamsResponse_progressUpdateStreamSummaryList :: Lens.Lens' ListProgressUpdateStreamsResponse (Prelude.Maybe [ProgressUpdateStreamSummary])
listProgressUpdateStreamsResponse_progressUpdateStreamSummaryList :: Lens'
  ListProgressUpdateStreamsResponse
  (Maybe [ProgressUpdateStreamSummary])
listProgressUpdateStreamsResponse_progressUpdateStreamSummaryList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProgressUpdateStreamsResponse' {Maybe [ProgressUpdateStreamSummary]
progressUpdateStreamSummaryList :: Maybe [ProgressUpdateStreamSummary]
$sel:progressUpdateStreamSummaryList:ListProgressUpdateStreamsResponse' :: ListProgressUpdateStreamsResponse
-> Maybe [ProgressUpdateStreamSummary]
progressUpdateStreamSummaryList} -> Maybe [ProgressUpdateStreamSummary]
progressUpdateStreamSummaryList) (\s :: ListProgressUpdateStreamsResponse
s@ListProgressUpdateStreamsResponse' {} Maybe [ProgressUpdateStreamSummary]
a -> ListProgressUpdateStreamsResponse
s {$sel:progressUpdateStreamSummaryList:ListProgressUpdateStreamsResponse' :: Maybe [ProgressUpdateStreamSummary]
progressUpdateStreamSummaryList = Maybe [ProgressUpdateStreamSummary]
a} :: ListProgressUpdateStreamsResponse) 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.
listProgressUpdateStreamsResponse_httpStatus :: Lens.Lens' ListProgressUpdateStreamsResponse Prelude.Int
listProgressUpdateStreamsResponse_httpStatus :: Lens' ListProgressUpdateStreamsResponse Int
listProgressUpdateStreamsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListProgressUpdateStreamsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListProgressUpdateStreamsResponse' :: ListProgressUpdateStreamsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListProgressUpdateStreamsResponse
s@ListProgressUpdateStreamsResponse' {} Int
a -> ListProgressUpdateStreamsResponse
s {$sel:httpStatus:ListProgressUpdateStreamsResponse' :: Int
httpStatus = Int
a} :: ListProgressUpdateStreamsResponse)

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