{-# 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.IoTDeviceAdvisor.ListSuiteRuns
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Lists the runs of the specified Device Advisor test suite. You can list
-- all runs of the test suite, or the runs of a specific version of the
-- test suite.
module Amazonka.IoTDeviceAdvisor.ListSuiteRuns
  ( -- * Creating a Request
    ListSuiteRuns (..),
    newListSuiteRuns,

    -- * Request Lenses
    listSuiteRuns_suiteDefinitionId,
    listSuiteRuns_suiteDefinitionVersion,
    listSuiteRuns_nextToken,
    listSuiteRuns_maxResults,

    -- * Destructuring the Response
    ListSuiteRunsResponse (..),
    newListSuiteRunsResponse,

    -- * Response Lenses
    listSuiteRunsResponse_nextToken,
    listSuiteRunsResponse_suiteRunsList,
    listSuiteRunsResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.IoTDeviceAdvisor.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newListSuiteRuns' smart constructor.
data ListSuiteRuns = ListSuiteRuns'
  { -- | Lists the test suite runs of the specified test suite based on suite
    -- definition Id.
    ListSuiteRuns -> Maybe Text
suiteDefinitionId :: Prelude.Maybe Prelude.Text,
    -- | Must be passed along with suiteDefinitionId. Lists the test suite runs
    -- of the specified test suite based on suite definition version.
    ListSuiteRuns -> Maybe Text
suiteDefinitionVersion :: Prelude.Maybe Prelude.Text,
    -- | A token to retrieve the next set of results.
    ListSuiteRuns -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of results to return at once.
    ListSuiteRuns -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural
  }
  deriving (ListSuiteRuns -> ListSuiteRuns -> Bool
(ListSuiteRuns -> ListSuiteRuns -> Bool)
-> (ListSuiteRuns -> ListSuiteRuns -> Bool) -> Eq ListSuiteRuns
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListSuiteRuns -> ListSuiteRuns -> Bool
$c/= :: ListSuiteRuns -> ListSuiteRuns -> Bool
== :: ListSuiteRuns -> ListSuiteRuns -> Bool
$c== :: ListSuiteRuns -> ListSuiteRuns -> Bool
Prelude.Eq, ReadPrec [ListSuiteRuns]
ReadPrec ListSuiteRuns
Int -> ReadS ListSuiteRuns
ReadS [ListSuiteRuns]
(Int -> ReadS ListSuiteRuns)
-> ReadS [ListSuiteRuns]
-> ReadPrec ListSuiteRuns
-> ReadPrec [ListSuiteRuns]
-> Read ListSuiteRuns
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListSuiteRuns]
$creadListPrec :: ReadPrec [ListSuiteRuns]
readPrec :: ReadPrec ListSuiteRuns
$creadPrec :: ReadPrec ListSuiteRuns
readList :: ReadS [ListSuiteRuns]
$creadList :: ReadS [ListSuiteRuns]
readsPrec :: Int -> ReadS ListSuiteRuns
$creadsPrec :: Int -> ReadS ListSuiteRuns
Prelude.Read, Int -> ListSuiteRuns -> ShowS
[ListSuiteRuns] -> ShowS
ListSuiteRuns -> String
(Int -> ListSuiteRuns -> ShowS)
-> (ListSuiteRuns -> String)
-> ([ListSuiteRuns] -> ShowS)
-> Show ListSuiteRuns
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListSuiteRuns] -> ShowS
$cshowList :: [ListSuiteRuns] -> ShowS
show :: ListSuiteRuns -> String
$cshow :: ListSuiteRuns -> String
showsPrec :: Int -> ListSuiteRuns -> ShowS
$cshowsPrec :: Int -> ListSuiteRuns -> ShowS
Prelude.Show, (forall x. ListSuiteRuns -> Rep ListSuiteRuns x)
-> (forall x. Rep ListSuiteRuns x -> ListSuiteRuns)
-> Generic ListSuiteRuns
forall x. Rep ListSuiteRuns x -> ListSuiteRuns
forall x. ListSuiteRuns -> Rep ListSuiteRuns x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListSuiteRuns x -> ListSuiteRuns
$cfrom :: forall x. ListSuiteRuns -> Rep ListSuiteRuns x
Prelude.Generic)

-- |
-- Create a value of 'ListSuiteRuns' 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:
--
-- 'suiteDefinitionId', 'listSuiteRuns_suiteDefinitionId' - Lists the test suite runs of the specified test suite based on suite
-- definition Id.
--
-- 'suiteDefinitionVersion', 'listSuiteRuns_suiteDefinitionVersion' - Must be passed along with suiteDefinitionId. Lists the test suite runs
-- of the specified test suite based on suite definition version.
--
-- 'nextToken', 'listSuiteRuns_nextToken' - A token to retrieve the next set of results.
--
-- 'maxResults', 'listSuiteRuns_maxResults' - The maximum number of results to return at once.
newListSuiteRuns ::
  ListSuiteRuns
newListSuiteRuns :: ListSuiteRuns
newListSuiteRuns =
  ListSuiteRuns' :: Maybe Text
-> Maybe Text -> Maybe Text -> Maybe Natural -> ListSuiteRuns
ListSuiteRuns'
    { $sel:suiteDefinitionId:ListSuiteRuns' :: Maybe Text
suiteDefinitionId = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:suiteDefinitionVersion:ListSuiteRuns' :: Maybe Text
suiteDefinitionVersion = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListSuiteRuns' :: Maybe Text
nextToken = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListSuiteRuns' :: Maybe Natural
maxResults = Maybe Natural
forall a. Maybe a
Prelude.Nothing
    }

-- | Lists the test suite runs of the specified test suite based on suite
-- definition Id.
listSuiteRuns_suiteDefinitionId :: Lens.Lens' ListSuiteRuns (Prelude.Maybe Prelude.Text)
listSuiteRuns_suiteDefinitionId :: (Maybe Text -> f (Maybe Text)) -> ListSuiteRuns -> f ListSuiteRuns
listSuiteRuns_suiteDefinitionId = (ListSuiteRuns -> Maybe Text)
-> (ListSuiteRuns -> Maybe Text -> ListSuiteRuns)
-> Lens ListSuiteRuns ListSuiteRuns (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSuiteRuns' {Maybe Text
suiteDefinitionId :: Maybe Text
$sel:suiteDefinitionId:ListSuiteRuns' :: ListSuiteRuns -> Maybe Text
suiteDefinitionId} -> Maybe Text
suiteDefinitionId) (\s :: ListSuiteRuns
s@ListSuiteRuns' {} Maybe Text
a -> ListSuiteRuns
s {$sel:suiteDefinitionId:ListSuiteRuns' :: Maybe Text
suiteDefinitionId = Maybe Text
a} :: ListSuiteRuns)

-- | Must be passed along with suiteDefinitionId. Lists the test suite runs
-- of the specified test suite based on suite definition version.
listSuiteRuns_suiteDefinitionVersion :: Lens.Lens' ListSuiteRuns (Prelude.Maybe Prelude.Text)
listSuiteRuns_suiteDefinitionVersion :: (Maybe Text -> f (Maybe Text)) -> ListSuiteRuns -> f ListSuiteRuns
listSuiteRuns_suiteDefinitionVersion = (ListSuiteRuns -> Maybe Text)
-> (ListSuiteRuns -> Maybe Text -> ListSuiteRuns)
-> Lens ListSuiteRuns ListSuiteRuns (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSuiteRuns' {Maybe Text
suiteDefinitionVersion :: Maybe Text
$sel:suiteDefinitionVersion:ListSuiteRuns' :: ListSuiteRuns -> Maybe Text
suiteDefinitionVersion} -> Maybe Text
suiteDefinitionVersion) (\s :: ListSuiteRuns
s@ListSuiteRuns' {} Maybe Text
a -> ListSuiteRuns
s {$sel:suiteDefinitionVersion:ListSuiteRuns' :: Maybe Text
suiteDefinitionVersion = Maybe Text
a} :: ListSuiteRuns)

-- | A token to retrieve the next set of results.
listSuiteRuns_nextToken :: Lens.Lens' ListSuiteRuns (Prelude.Maybe Prelude.Text)
listSuiteRuns_nextToken :: (Maybe Text -> f (Maybe Text)) -> ListSuiteRuns -> f ListSuiteRuns
listSuiteRuns_nextToken = (ListSuiteRuns -> Maybe Text)
-> (ListSuiteRuns -> Maybe Text -> ListSuiteRuns)
-> Lens ListSuiteRuns ListSuiteRuns (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSuiteRuns' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListSuiteRuns' :: ListSuiteRuns -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSuiteRuns
s@ListSuiteRuns' {} Maybe Text
a -> ListSuiteRuns
s {$sel:nextToken:ListSuiteRuns' :: Maybe Text
nextToken = Maybe Text
a} :: ListSuiteRuns)

-- | The maximum number of results to return at once.
listSuiteRuns_maxResults :: Lens.Lens' ListSuiteRuns (Prelude.Maybe Prelude.Natural)
listSuiteRuns_maxResults :: (Maybe Natural -> f (Maybe Natural))
-> ListSuiteRuns -> f ListSuiteRuns
listSuiteRuns_maxResults = (ListSuiteRuns -> Maybe Natural)
-> (ListSuiteRuns -> Maybe Natural -> ListSuiteRuns)
-> Lens ListSuiteRuns ListSuiteRuns (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSuiteRuns' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListSuiteRuns' :: ListSuiteRuns -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListSuiteRuns
s@ListSuiteRuns' {} Maybe Natural
a -> ListSuiteRuns
s {$sel:maxResults:ListSuiteRuns' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListSuiteRuns)

instance Core.AWSRequest ListSuiteRuns where
  type
    AWSResponse ListSuiteRuns =
      ListSuiteRunsResponse
  request :: ListSuiteRuns -> Request ListSuiteRuns
request = Service -> ListSuiteRuns -> Request ListSuiteRuns
forall a. ToRequest a => Service -> a -> Request a
Request.get Service
defaultService
  response :: Logger
-> Service
-> Proxy ListSuiteRuns
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListSuiteRuns)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse ListSuiteRuns))
-> Logger
-> Service
-> Proxy ListSuiteRuns
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ListSuiteRuns)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe [SuiteRunInformation] -> Int -> ListSuiteRunsResponse
ListSuiteRunsResponse'
            (Maybe Text
 -> Maybe [SuiteRunInformation] -> Int -> ListSuiteRunsResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe [SuiteRunInformation] -> Int -> ListSuiteRunsResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"nextToken")
            Either
  String
  (Maybe [SuiteRunInformation] -> Int -> ListSuiteRunsResponse)
-> Either String (Maybe [SuiteRunInformation])
-> Either String (Int -> ListSuiteRunsResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object
-> Text -> Either String (Maybe (Maybe [SuiteRunInformation]))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"suiteRunsList" Either String (Maybe (Maybe [SuiteRunInformation]))
-> Maybe [SuiteRunInformation]
-> Either String (Maybe [SuiteRunInformation])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [SuiteRunInformation]
forall a. Monoid a => a
Prelude.mempty)
            Either String (Int -> ListSuiteRunsResponse)
-> Either String Int -> Either String ListSuiteRunsResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ListSuiteRuns

instance Prelude.NFData ListSuiteRuns

instance Core.ToHeaders ListSuiteRuns where
  toHeaders :: ListSuiteRuns -> ResponseHeaders
toHeaders =
    ResponseHeaders -> ListSuiteRuns -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToPath ListSuiteRuns where
  toPath :: ListSuiteRuns -> ByteString
toPath = ByteString -> ListSuiteRuns -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/suiteRuns"

instance Core.ToQuery ListSuiteRuns where
  toQuery :: ListSuiteRuns -> QueryString
toQuery ListSuiteRuns' {Maybe Natural
Maybe Text
maxResults :: Maybe Natural
nextToken :: Maybe Text
suiteDefinitionVersion :: Maybe Text
suiteDefinitionId :: Maybe Text
$sel:maxResults:ListSuiteRuns' :: ListSuiteRuns -> Maybe Natural
$sel:nextToken:ListSuiteRuns' :: ListSuiteRuns -> Maybe Text
$sel:suiteDefinitionVersion:ListSuiteRuns' :: ListSuiteRuns -> Maybe Text
$sel:suiteDefinitionId:ListSuiteRuns' :: ListSuiteRuns -> Maybe Text
..} =
    [QueryString] -> QueryString
forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"suiteDefinitionId" ByteString -> Maybe Text -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Text
suiteDefinitionId,
        ByteString
"suiteDefinitionVersion"
          ByteString -> Maybe Text -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Text
suiteDefinitionVersion,
        ByteString
"nextToken" ByteString -> Maybe Text -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Text
nextToken,
        ByteString
"maxResults" ByteString -> Maybe Natural -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Natural
maxResults
      ]

-- | /See:/ 'newListSuiteRunsResponse' smart constructor.
data ListSuiteRunsResponse = ListSuiteRunsResponse'
  { -- | A token to retrieve the next set of results.
    ListSuiteRunsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | An array of objects that provide summaries of information about the
    -- suite runs in the list.
    ListSuiteRunsResponse -> Maybe [SuiteRunInformation]
suiteRunsList :: Prelude.Maybe [SuiteRunInformation],
    -- | The response's http status code.
    ListSuiteRunsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListSuiteRunsResponse -> ListSuiteRunsResponse -> Bool
(ListSuiteRunsResponse -> ListSuiteRunsResponse -> Bool)
-> (ListSuiteRunsResponse -> ListSuiteRunsResponse -> Bool)
-> Eq ListSuiteRunsResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListSuiteRunsResponse -> ListSuiteRunsResponse -> Bool
$c/= :: ListSuiteRunsResponse -> ListSuiteRunsResponse -> Bool
== :: ListSuiteRunsResponse -> ListSuiteRunsResponse -> Bool
$c== :: ListSuiteRunsResponse -> ListSuiteRunsResponse -> Bool
Prelude.Eq, ReadPrec [ListSuiteRunsResponse]
ReadPrec ListSuiteRunsResponse
Int -> ReadS ListSuiteRunsResponse
ReadS [ListSuiteRunsResponse]
(Int -> ReadS ListSuiteRunsResponse)
-> ReadS [ListSuiteRunsResponse]
-> ReadPrec ListSuiteRunsResponse
-> ReadPrec [ListSuiteRunsResponse]
-> Read ListSuiteRunsResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListSuiteRunsResponse]
$creadListPrec :: ReadPrec [ListSuiteRunsResponse]
readPrec :: ReadPrec ListSuiteRunsResponse
$creadPrec :: ReadPrec ListSuiteRunsResponse
readList :: ReadS [ListSuiteRunsResponse]
$creadList :: ReadS [ListSuiteRunsResponse]
readsPrec :: Int -> ReadS ListSuiteRunsResponse
$creadsPrec :: Int -> ReadS ListSuiteRunsResponse
Prelude.Read, Int -> ListSuiteRunsResponse -> ShowS
[ListSuiteRunsResponse] -> ShowS
ListSuiteRunsResponse -> String
(Int -> ListSuiteRunsResponse -> ShowS)
-> (ListSuiteRunsResponse -> String)
-> ([ListSuiteRunsResponse] -> ShowS)
-> Show ListSuiteRunsResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListSuiteRunsResponse] -> ShowS
$cshowList :: [ListSuiteRunsResponse] -> ShowS
show :: ListSuiteRunsResponse -> String
$cshow :: ListSuiteRunsResponse -> String
showsPrec :: Int -> ListSuiteRunsResponse -> ShowS
$cshowsPrec :: Int -> ListSuiteRunsResponse -> ShowS
Prelude.Show, (forall x. ListSuiteRunsResponse -> Rep ListSuiteRunsResponse x)
-> (forall x. Rep ListSuiteRunsResponse x -> ListSuiteRunsResponse)
-> Generic ListSuiteRunsResponse
forall x. Rep ListSuiteRunsResponse x -> ListSuiteRunsResponse
forall x. ListSuiteRunsResponse -> Rep ListSuiteRunsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListSuiteRunsResponse x -> ListSuiteRunsResponse
$cfrom :: forall x. ListSuiteRunsResponse -> Rep ListSuiteRunsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListSuiteRunsResponse' 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', 'listSuiteRunsResponse_nextToken' - A token to retrieve the next set of results.
--
-- 'suiteRunsList', 'listSuiteRunsResponse_suiteRunsList' - An array of objects that provide summaries of information about the
-- suite runs in the list.
--
-- 'httpStatus', 'listSuiteRunsResponse_httpStatus' - The response's http status code.
newListSuiteRunsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListSuiteRunsResponse
newListSuiteRunsResponse :: Int -> ListSuiteRunsResponse
newListSuiteRunsResponse Int
pHttpStatus_ =
  ListSuiteRunsResponse' :: Maybe Text
-> Maybe [SuiteRunInformation] -> Int -> ListSuiteRunsResponse
ListSuiteRunsResponse'
    { $sel:nextToken:ListSuiteRunsResponse' :: Maybe Text
nextToken = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:suiteRunsList:ListSuiteRunsResponse' :: Maybe [SuiteRunInformation]
suiteRunsList = Maybe [SuiteRunInformation]
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListSuiteRunsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A token to retrieve the next set of results.
listSuiteRunsResponse_nextToken :: Lens.Lens' ListSuiteRunsResponse (Prelude.Maybe Prelude.Text)
listSuiteRunsResponse_nextToken :: (Maybe Text -> f (Maybe Text))
-> ListSuiteRunsResponse -> f ListSuiteRunsResponse
listSuiteRunsResponse_nextToken = (ListSuiteRunsResponse -> Maybe Text)
-> (ListSuiteRunsResponse -> Maybe Text -> ListSuiteRunsResponse)
-> Lens
     ListSuiteRunsResponse
     ListSuiteRunsResponse
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSuiteRunsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListSuiteRunsResponse' :: ListSuiteRunsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListSuiteRunsResponse
s@ListSuiteRunsResponse' {} Maybe Text
a -> ListSuiteRunsResponse
s {$sel:nextToken:ListSuiteRunsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListSuiteRunsResponse)

-- | An array of objects that provide summaries of information about the
-- suite runs in the list.
listSuiteRunsResponse_suiteRunsList :: Lens.Lens' ListSuiteRunsResponse (Prelude.Maybe [SuiteRunInformation])
listSuiteRunsResponse_suiteRunsList :: (Maybe [SuiteRunInformation] -> f (Maybe [SuiteRunInformation]))
-> ListSuiteRunsResponse -> f ListSuiteRunsResponse
listSuiteRunsResponse_suiteRunsList = (ListSuiteRunsResponse -> Maybe [SuiteRunInformation])
-> (ListSuiteRunsResponse
    -> Maybe [SuiteRunInformation] -> ListSuiteRunsResponse)
-> Lens
     ListSuiteRunsResponse
     ListSuiteRunsResponse
     (Maybe [SuiteRunInformation])
     (Maybe [SuiteRunInformation])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListSuiteRunsResponse' {Maybe [SuiteRunInformation]
suiteRunsList :: Maybe [SuiteRunInformation]
$sel:suiteRunsList:ListSuiteRunsResponse' :: ListSuiteRunsResponse -> Maybe [SuiteRunInformation]
suiteRunsList} -> Maybe [SuiteRunInformation]
suiteRunsList) (\s :: ListSuiteRunsResponse
s@ListSuiteRunsResponse' {} Maybe [SuiteRunInformation]
a -> ListSuiteRunsResponse
s {$sel:suiteRunsList:ListSuiteRunsResponse' :: Maybe [SuiteRunInformation]
suiteRunsList = Maybe [SuiteRunInformation]
a} :: ListSuiteRunsResponse) ((Maybe [SuiteRunInformation] -> f (Maybe [SuiteRunInformation]))
 -> ListSuiteRunsResponse -> f ListSuiteRunsResponse)
-> ((Maybe [SuiteRunInformation]
     -> f (Maybe [SuiteRunInformation]))
    -> Maybe [SuiteRunInformation] -> f (Maybe [SuiteRunInformation]))
-> (Maybe [SuiteRunInformation] -> f (Maybe [SuiteRunInformation]))
-> ListSuiteRunsResponse
-> f ListSuiteRunsResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [SuiteRunInformation]
  [SuiteRunInformation]
  [SuiteRunInformation]
  [SuiteRunInformation]
-> Iso
     (Maybe [SuiteRunInformation])
     (Maybe [SuiteRunInformation])
     (Maybe [SuiteRunInformation])
     (Maybe [SuiteRunInformation])
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 AnIso
  [SuiteRunInformation]
  [SuiteRunInformation]
  [SuiteRunInformation]
  [SuiteRunInformation]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Prelude.NFData ListSuiteRunsResponse