{-# 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.Omics.ListRunTasks
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves a list of tasks for a run.
--
-- This operation returns paginated results.
module Amazonka.Omics.ListRunTasks
  ( -- * Creating a Request
    ListRunTasks (..),
    newListRunTasks,

    -- * Request Lenses
    listRunTasks_maxResults,
    listRunTasks_startingToken,
    listRunTasks_status,
    listRunTasks_id,

    -- * Destructuring the Response
    ListRunTasksResponse (..),
    newListRunTasksResponse,

    -- * Response Lenses
    listRunTasksResponse_items,
    listRunTasksResponse_nextToken,
    listRunTasksResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListRunTasks' smart constructor.
data ListRunTasks = ListRunTasks'
  { -- | The maximum number of run tasks to return in one page of results.
    ListRunTasks -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | Specify the pagination token from a previous request to retrieve the
    -- next page of results.
    ListRunTasks -> Maybe Text
startingToken :: Prelude.Maybe Prelude.Text,
    -- | Filter the list by status.
    ListRunTasks -> Maybe TaskStatus
status :: Prelude.Maybe TaskStatus,
    -- | The run\'s ID.
    ListRunTasks -> Text
id :: Prelude.Text
  }
  deriving (ListRunTasks -> ListRunTasks -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListRunTasks -> ListRunTasks -> Bool
$c/= :: ListRunTasks -> ListRunTasks -> Bool
== :: ListRunTasks -> ListRunTasks -> Bool
$c== :: ListRunTasks -> ListRunTasks -> Bool
Prelude.Eq, ReadPrec [ListRunTasks]
ReadPrec ListRunTasks
Int -> ReadS ListRunTasks
ReadS [ListRunTasks]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListRunTasks]
$creadListPrec :: ReadPrec [ListRunTasks]
readPrec :: ReadPrec ListRunTasks
$creadPrec :: ReadPrec ListRunTasks
readList :: ReadS [ListRunTasks]
$creadList :: ReadS [ListRunTasks]
readsPrec :: Int -> ReadS ListRunTasks
$creadsPrec :: Int -> ReadS ListRunTasks
Prelude.Read, Int -> ListRunTasks -> ShowS
[ListRunTasks] -> ShowS
ListRunTasks -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListRunTasks] -> ShowS
$cshowList :: [ListRunTasks] -> ShowS
show :: ListRunTasks -> String
$cshow :: ListRunTasks -> String
showsPrec :: Int -> ListRunTasks -> ShowS
$cshowsPrec :: Int -> ListRunTasks -> ShowS
Prelude.Show, forall x. Rep ListRunTasks x -> ListRunTasks
forall x. ListRunTasks -> Rep ListRunTasks x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListRunTasks x -> ListRunTasks
$cfrom :: forall x. ListRunTasks -> Rep ListRunTasks x
Prelude.Generic)

-- |
-- Create a value of 'ListRunTasks' 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', 'listRunTasks_maxResults' - The maximum number of run tasks to return in one page of results.
--
-- 'startingToken', 'listRunTasks_startingToken' - Specify the pagination token from a previous request to retrieve the
-- next page of results.
--
-- 'status', 'listRunTasks_status' - Filter the list by status.
--
-- 'id', 'listRunTasks_id' - The run\'s ID.
newListRunTasks ::
  -- | 'id'
  Prelude.Text ->
  ListRunTasks
newListRunTasks :: Text -> ListRunTasks
newListRunTasks Text
pId_ =
  ListRunTasks'
    { $sel:maxResults:ListRunTasks' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:startingToken:ListRunTasks' :: Maybe Text
startingToken = forall a. Maybe a
Prelude.Nothing,
      $sel:status:ListRunTasks' :: Maybe TaskStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:id:ListRunTasks' :: Text
id = Text
pId_
    }

-- | The maximum number of run tasks to return in one page of results.
listRunTasks_maxResults :: Lens.Lens' ListRunTasks (Prelude.Maybe Prelude.Natural)
listRunTasks_maxResults :: Lens' ListRunTasks (Maybe Natural)
listRunTasks_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListRunTasks' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListRunTasks' :: ListRunTasks -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListRunTasks
s@ListRunTasks' {} Maybe Natural
a -> ListRunTasks
s {$sel:maxResults:ListRunTasks' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListRunTasks)

-- | Specify the pagination token from a previous request to retrieve the
-- next page of results.
listRunTasks_startingToken :: Lens.Lens' ListRunTasks (Prelude.Maybe Prelude.Text)
listRunTasks_startingToken :: Lens' ListRunTasks (Maybe Text)
listRunTasks_startingToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListRunTasks' {Maybe Text
startingToken :: Maybe Text
$sel:startingToken:ListRunTasks' :: ListRunTasks -> Maybe Text
startingToken} -> Maybe Text
startingToken) (\s :: ListRunTasks
s@ListRunTasks' {} Maybe Text
a -> ListRunTasks
s {$sel:startingToken:ListRunTasks' :: Maybe Text
startingToken = Maybe Text
a} :: ListRunTasks)

-- | Filter the list by status.
listRunTasks_status :: Lens.Lens' ListRunTasks (Prelude.Maybe TaskStatus)
listRunTasks_status :: Lens' ListRunTasks (Maybe TaskStatus)
listRunTasks_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListRunTasks' {Maybe TaskStatus
status :: Maybe TaskStatus
$sel:status:ListRunTasks' :: ListRunTasks -> Maybe TaskStatus
status} -> Maybe TaskStatus
status) (\s :: ListRunTasks
s@ListRunTasks' {} Maybe TaskStatus
a -> ListRunTasks
s {$sel:status:ListRunTasks' :: Maybe TaskStatus
status = Maybe TaskStatus
a} :: ListRunTasks)

-- | The run\'s ID.
listRunTasks_id :: Lens.Lens' ListRunTasks Prelude.Text
listRunTasks_id :: Lens' ListRunTasks Text
listRunTasks_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListRunTasks' {Text
id :: Text
$sel:id:ListRunTasks' :: ListRunTasks -> Text
id} -> Text
id) (\s :: ListRunTasks
s@ListRunTasks' {} Text
a -> ListRunTasks
s {$sel:id:ListRunTasks' :: Text
id = Text
a} :: ListRunTasks)

instance Core.AWSPager ListRunTasks where
  page :: ListRunTasks -> AWSResponse ListRunTasks -> Maybe ListRunTasks
page ListRunTasks
rq AWSResponse ListRunTasks
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListRunTasks
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListRunTasksResponse (Maybe Text)
listRunTasksResponse_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 ListRunTasks
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListRunTasksResponse (Maybe [TaskListItem])
listRunTasksResponse_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.$ ListRunTasks
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListRunTasks (Maybe Text)
listRunTasks_startingToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListRunTasks
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListRunTasksResponse (Maybe Text)
listRunTasksResponse_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 ListRunTasks where
  type AWSResponse ListRunTasks = ListRunTasksResponse
  request :: (Service -> Service) -> ListRunTasks -> Request ListRunTasks
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 ListRunTasks
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListRunTasks)))
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 [TaskListItem] -> Maybe Text -> Int -> ListRunTasksResponse
ListRunTasksResponse'
            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 ListRunTasks where
  hashWithSalt :: Int -> ListRunTasks -> Int
hashWithSalt Int
_salt ListRunTasks' {Maybe Natural
Maybe Text
Maybe TaskStatus
Text
id :: Text
status :: Maybe TaskStatus
startingToken :: Maybe Text
maxResults :: Maybe Natural
$sel:id:ListRunTasks' :: ListRunTasks -> Text
$sel:status:ListRunTasks' :: ListRunTasks -> Maybe TaskStatus
$sel:startingToken:ListRunTasks' :: ListRunTasks -> Maybe Text
$sel:maxResults:ListRunTasks' :: ListRunTasks -> 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
startingToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TaskStatus
status
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
id

instance Prelude.NFData ListRunTasks where
  rnf :: ListRunTasks -> ()
rnf ListRunTasks' {Maybe Natural
Maybe Text
Maybe TaskStatus
Text
id :: Text
status :: Maybe TaskStatus
startingToken :: Maybe Text
maxResults :: Maybe Natural
$sel:id:ListRunTasks' :: ListRunTasks -> Text
$sel:status:ListRunTasks' :: ListRunTasks -> Maybe TaskStatus
$sel:startingToken:ListRunTasks' :: ListRunTasks -> Maybe Text
$sel:maxResults:ListRunTasks' :: ListRunTasks -> 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
startingToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TaskStatus
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
id

instance Data.ToHeaders ListRunTasks where
  toHeaders :: ListRunTasks -> 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 ListRunTasks where
  toPath :: ListRunTasks -> ByteString
toPath ListRunTasks' {Maybe Natural
Maybe Text
Maybe TaskStatus
Text
id :: Text
status :: Maybe TaskStatus
startingToken :: Maybe Text
maxResults :: Maybe Natural
$sel:id:ListRunTasks' :: ListRunTasks -> Text
$sel:status:ListRunTasks' :: ListRunTasks -> Maybe TaskStatus
$sel:startingToken:ListRunTasks' :: ListRunTasks -> Maybe Text
$sel:maxResults:ListRunTasks' :: ListRunTasks -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat [ByteString
"/run/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
id, ByteString
"/task"]

instance Data.ToQuery ListRunTasks where
  toQuery :: ListRunTasks -> QueryString
toQuery ListRunTasks' {Maybe Natural
Maybe Text
Maybe TaskStatus
Text
id :: Text
status :: Maybe TaskStatus
startingToken :: Maybe Text
maxResults :: Maybe Natural
$sel:id:ListRunTasks' :: ListRunTasks -> Text
$sel:status:ListRunTasks' :: ListRunTasks -> Maybe TaskStatus
$sel:startingToken:ListRunTasks' :: ListRunTasks -> Maybe Text
$sel:maxResults:ListRunTasks' :: ListRunTasks -> Maybe Natural
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"startingToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
startingToken,
        ByteString
"status" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe TaskStatus
status
      ]

-- | /See:/ 'newListRunTasksResponse' smart constructor.
data ListRunTasksResponse = ListRunTasksResponse'
  { -- | A list of tasks.
    ListRunTasksResponse -> Maybe [TaskListItem]
items :: Prelude.Maybe [TaskListItem],
    -- | A pagination token that\'s included if more results are available.
    ListRunTasksResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListRunTasksResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListRunTasksResponse -> ListRunTasksResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListRunTasksResponse -> ListRunTasksResponse -> Bool
$c/= :: ListRunTasksResponse -> ListRunTasksResponse -> Bool
== :: ListRunTasksResponse -> ListRunTasksResponse -> Bool
$c== :: ListRunTasksResponse -> ListRunTasksResponse -> Bool
Prelude.Eq, ReadPrec [ListRunTasksResponse]
ReadPrec ListRunTasksResponse
Int -> ReadS ListRunTasksResponse
ReadS [ListRunTasksResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListRunTasksResponse]
$creadListPrec :: ReadPrec [ListRunTasksResponse]
readPrec :: ReadPrec ListRunTasksResponse
$creadPrec :: ReadPrec ListRunTasksResponse
readList :: ReadS [ListRunTasksResponse]
$creadList :: ReadS [ListRunTasksResponse]
readsPrec :: Int -> ReadS ListRunTasksResponse
$creadsPrec :: Int -> ReadS ListRunTasksResponse
Prelude.Read, Int -> ListRunTasksResponse -> ShowS
[ListRunTasksResponse] -> ShowS
ListRunTasksResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListRunTasksResponse] -> ShowS
$cshowList :: [ListRunTasksResponse] -> ShowS
show :: ListRunTasksResponse -> String
$cshow :: ListRunTasksResponse -> String
showsPrec :: Int -> ListRunTasksResponse -> ShowS
$cshowsPrec :: Int -> ListRunTasksResponse -> ShowS
Prelude.Show, forall x. Rep ListRunTasksResponse x -> ListRunTasksResponse
forall x. ListRunTasksResponse -> Rep ListRunTasksResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListRunTasksResponse x -> ListRunTasksResponse
$cfrom :: forall x. ListRunTasksResponse -> Rep ListRunTasksResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListRunTasksResponse' 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', 'listRunTasksResponse_items' - A list of tasks.
--
-- 'nextToken', 'listRunTasksResponse_nextToken' - A pagination token that\'s included if more results are available.
--
-- 'httpStatus', 'listRunTasksResponse_httpStatus' - The response's http status code.
newListRunTasksResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListRunTasksResponse
newListRunTasksResponse :: Int -> ListRunTasksResponse
newListRunTasksResponse Int
pHttpStatus_ =
  ListRunTasksResponse'
    { $sel:items:ListRunTasksResponse' :: Maybe [TaskListItem]
items = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListRunTasksResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListRunTasksResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of tasks.
listRunTasksResponse_items :: Lens.Lens' ListRunTasksResponse (Prelude.Maybe [TaskListItem])
listRunTasksResponse_items :: Lens' ListRunTasksResponse (Maybe [TaskListItem])
listRunTasksResponse_items = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListRunTasksResponse' {Maybe [TaskListItem]
items :: Maybe [TaskListItem]
$sel:items:ListRunTasksResponse' :: ListRunTasksResponse -> Maybe [TaskListItem]
items} -> Maybe [TaskListItem]
items) (\s :: ListRunTasksResponse
s@ListRunTasksResponse' {} Maybe [TaskListItem]
a -> ListRunTasksResponse
s {$sel:items:ListRunTasksResponse' :: Maybe [TaskListItem]
items = Maybe [TaskListItem]
a} :: ListRunTasksResponse) 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 that\'s included if more results are available.
listRunTasksResponse_nextToken :: Lens.Lens' ListRunTasksResponse (Prelude.Maybe Prelude.Text)
listRunTasksResponse_nextToken :: Lens' ListRunTasksResponse (Maybe Text)
listRunTasksResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListRunTasksResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListRunTasksResponse' :: ListRunTasksResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListRunTasksResponse
s@ListRunTasksResponse' {} Maybe Text
a -> ListRunTasksResponse
s {$sel:nextToken:ListRunTasksResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListRunTasksResponse)

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

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