{-# 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.DeviceFarm.ListUniqueProblems
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets information about unique problems, such as exceptions or crashes.
--
-- Unique problems are defined as a single instance of an error across a
-- run, job, or suite. For example, if a call in your application
-- consistently raises an exception
-- (@OutOfBoundsException in MyActivity.java:386@), @ListUniqueProblems@
-- returns a single entry instead of many individual entries for that
-- exception.
--
-- This operation returns paginated results.
module Amazonka.DeviceFarm.ListUniqueProblems
  ( -- * Creating a Request
    ListUniqueProblems (..),
    newListUniqueProblems,

    -- * Request Lenses
    listUniqueProblems_nextToken,
    listUniqueProblems_arn,

    -- * Destructuring the Response
    ListUniqueProblemsResponse (..),
    newListUniqueProblemsResponse,

    -- * Response Lenses
    listUniqueProblemsResponse_nextToken,
    listUniqueProblemsResponse_uniqueProblems,
    listUniqueProblemsResponse_httpStatus,
  )
where

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

-- | Represents a request to the list unique problems operation.
--
-- /See:/ 'newListUniqueProblems' smart constructor.
data ListUniqueProblems = ListUniqueProblems'
  { -- | An identifier that was returned from the previous call to this
    -- operation, which can be used to return the next set of items in the
    -- list.
    ListUniqueProblems -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The unique problems\' ARNs.
    ListUniqueProblems -> Text
arn :: Prelude.Text
  }
  deriving (ListUniqueProblems -> ListUniqueProblems -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListUniqueProblems -> ListUniqueProblems -> Bool
$c/= :: ListUniqueProblems -> ListUniqueProblems -> Bool
== :: ListUniqueProblems -> ListUniqueProblems -> Bool
$c== :: ListUniqueProblems -> ListUniqueProblems -> Bool
Prelude.Eq, ReadPrec [ListUniqueProblems]
ReadPrec ListUniqueProblems
Int -> ReadS ListUniqueProblems
ReadS [ListUniqueProblems]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListUniqueProblems]
$creadListPrec :: ReadPrec [ListUniqueProblems]
readPrec :: ReadPrec ListUniqueProblems
$creadPrec :: ReadPrec ListUniqueProblems
readList :: ReadS [ListUniqueProblems]
$creadList :: ReadS [ListUniqueProblems]
readsPrec :: Int -> ReadS ListUniqueProblems
$creadsPrec :: Int -> ReadS ListUniqueProblems
Prelude.Read, Int -> ListUniqueProblems -> ShowS
[ListUniqueProblems] -> ShowS
ListUniqueProblems -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListUniqueProblems] -> ShowS
$cshowList :: [ListUniqueProblems] -> ShowS
show :: ListUniqueProblems -> String
$cshow :: ListUniqueProblems -> String
showsPrec :: Int -> ListUniqueProblems -> ShowS
$cshowsPrec :: Int -> ListUniqueProblems -> ShowS
Prelude.Show, forall x. Rep ListUniqueProblems x -> ListUniqueProblems
forall x. ListUniqueProblems -> Rep ListUniqueProblems x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListUniqueProblems x -> ListUniqueProblems
$cfrom :: forall x. ListUniqueProblems -> Rep ListUniqueProblems x
Prelude.Generic)

-- |
-- Create a value of 'ListUniqueProblems' 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', 'listUniqueProblems_nextToken' - An identifier that was returned from the previous call to this
-- operation, which can be used to return the next set of items in the
-- list.
--
-- 'arn', 'listUniqueProblems_arn' - The unique problems\' ARNs.
newListUniqueProblems ::
  -- | 'arn'
  Prelude.Text ->
  ListUniqueProblems
newListUniqueProblems :: Text -> ListUniqueProblems
newListUniqueProblems Text
pArn_ =
  ListUniqueProblems'
    { $sel:nextToken:ListUniqueProblems' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:arn:ListUniqueProblems' :: Text
arn = Text
pArn_
    }

-- | An identifier that was returned from the previous call to this
-- operation, which can be used to return the next set of items in the
-- list.
listUniqueProblems_nextToken :: Lens.Lens' ListUniqueProblems (Prelude.Maybe Prelude.Text)
listUniqueProblems_nextToken :: Lens' ListUniqueProblems (Maybe Text)
listUniqueProblems_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblems' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListUniqueProblems' :: ListUniqueProblems -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListUniqueProblems
s@ListUniqueProblems' {} Maybe Text
a -> ListUniqueProblems
s {$sel:nextToken:ListUniqueProblems' :: Maybe Text
nextToken = Maybe Text
a} :: ListUniqueProblems)

-- | The unique problems\' ARNs.
listUniqueProblems_arn :: Lens.Lens' ListUniqueProblems Prelude.Text
listUniqueProblems_arn :: Lens' ListUniqueProblems Text
listUniqueProblems_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblems' {Text
arn :: Text
$sel:arn:ListUniqueProblems' :: ListUniqueProblems -> Text
arn} -> Text
arn) (\s :: ListUniqueProblems
s@ListUniqueProblems' {} Text
a -> ListUniqueProblems
s {$sel:arn:ListUniqueProblems' :: Text
arn = Text
a} :: ListUniqueProblems)

instance Core.AWSPager ListUniqueProblems where
  page :: ListUniqueProblems
-> AWSResponse ListUniqueProblems -> Maybe ListUniqueProblems
page ListUniqueProblems
rq AWSResponse ListUniqueProblems
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListUniqueProblems
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListUniqueProblemsResponse (Maybe Text)
listUniqueProblemsResponse_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 ListUniqueProblems
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListUniqueProblemsResponse
  (Maybe (HashMap ExecutionResult [UniqueProblem]))
listUniqueProblemsResponse_uniqueProblems
            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.$ ListUniqueProblems
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListUniqueProblems (Maybe Text)
listUniqueProblems_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListUniqueProblems
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListUniqueProblemsResponse (Maybe Text)
listUniqueProblemsResponse_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 ListUniqueProblems where
  type
    AWSResponse ListUniqueProblems =
      ListUniqueProblemsResponse
  request :: (Service -> Service)
-> ListUniqueProblems -> Request ListUniqueProblems
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 ListUniqueProblems
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListUniqueProblems)))
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 (HashMap ExecutionResult [UniqueProblem])
-> Int
-> ListUniqueProblemsResponse
ListUniqueProblemsResponse'
            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
"uniqueProblems" 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 ListUniqueProblems where
  hashWithSalt :: Int -> ListUniqueProblems -> Int
hashWithSalt Int
_salt ListUniqueProblems' {Maybe Text
Text
arn :: Text
nextToken :: Maybe Text
$sel:arn:ListUniqueProblems' :: ListUniqueProblems -> Text
$sel:nextToken:ListUniqueProblems' :: ListUniqueProblems -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
arn

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

instance Data.ToHeaders ListUniqueProblems where
  toHeaders :: ListUniqueProblems -> 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
"DeviceFarm_20150623.ListUniqueProblems" ::
                          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 ListUniqueProblems where
  toJSON :: ListUniqueProblems -> Value
toJSON ListUniqueProblems' {Maybe Text
Text
arn :: Text
nextToken :: Maybe Text
$sel:arn:ListUniqueProblems' :: ListUniqueProblems -> Text
$sel:nextToken:ListUniqueProblems' :: ListUniqueProblems -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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
"arn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
arn)
          ]
      )

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

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

-- | Represents the result of a list unique problems request.
--
-- /See:/ 'newListUniqueProblemsResponse' smart constructor.
data ListUniqueProblemsResponse = ListUniqueProblemsResponse'
  { -- | If the number of items that are returned is significantly large, this is
    -- an identifier that is also returned. It can be used in a subsequent call
    -- to this operation to return the next set of items in the list.
    ListUniqueProblemsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Information about the unique problems.
    --
    -- Allowed values include:
    --
    -- -   PENDING
    --
    -- -   PASSED
    --
    -- -   WARNED
    --
    -- -   FAILED
    --
    -- -   SKIPPED
    --
    -- -   ERRORED
    --
    -- -   STOPPED
    ListUniqueProblemsResponse
-> Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems :: Prelude.Maybe (Prelude.HashMap ExecutionResult [UniqueProblem]),
    -- | The response's http status code.
    ListUniqueProblemsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
$c/= :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
== :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
$c== :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
Prelude.Eq, ReadPrec [ListUniqueProblemsResponse]
ReadPrec ListUniqueProblemsResponse
Int -> ReadS ListUniqueProblemsResponse
ReadS [ListUniqueProblemsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListUniqueProblemsResponse]
$creadListPrec :: ReadPrec [ListUniqueProblemsResponse]
readPrec :: ReadPrec ListUniqueProblemsResponse
$creadPrec :: ReadPrec ListUniqueProblemsResponse
readList :: ReadS [ListUniqueProblemsResponse]
$creadList :: ReadS [ListUniqueProblemsResponse]
readsPrec :: Int -> ReadS ListUniqueProblemsResponse
$creadsPrec :: Int -> ReadS ListUniqueProblemsResponse
Prelude.Read, Int -> ListUniqueProblemsResponse -> ShowS
[ListUniqueProblemsResponse] -> ShowS
ListUniqueProblemsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListUniqueProblemsResponse] -> ShowS
$cshowList :: [ListUniqueProblemsResponse] -> ShowS
show :: ListUniqueProblemsResponse -> String
$cshow :: ListUniqueProblemsResponse -> String
showsPrec :: Int -> ListUniqueProblemsResponse -> ShowS
$cshowsPrec :: Int -> ListUniqueProblemsResponse -> ShowS
Prelude.Show, forall x.
Rep ListUniqueProblemsResponse x -> ListUniqueProblemsResponse
forall x.
ListUniqueProblemsResponse -> Rep ListUniqueProblemsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListUniqueProblemsResponse x -> ListUniqueProblemsResponse
$cfrom :: forall x.
ListUniqueProblemsResponse -> Rep ListUniqueProblemsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListUniqueProblemsResponse' 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', 'listUniqueProblemsResponse_nextToken' - If the number of items that are returned is significantly large, this is
-- an identifier that is also returned. It can be used in a subsequent call
-- to this operation to return the next set of items in the list.
--
-- 'uniqueProblems', 'listUniqueProblemsResponse_uniqueProblems' - Information about the unique problems.
--
-- Allowed values include:
--
-- -   PENDING
--
-- -   PASSED
--
-- -   WARNED
--
-- -   FAILED
--
-- -   SKIPPED
--
-- -   ERRORED
--
-- -   STOPPED
--
-- 'httpStatus', 'listUniqueProblemsResponse_httpStatus' - The response's http status code.
newListUniqueProblemsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListUniqueProblemsResponse
newListUniqueProblemsResponse :: Int -> ListUniqueProblemsResponse
newListUniqueProblemsResponse Int
pHttpStatus_ =
  ListUniqueProblemsResponse'
    { $sel:nextToken:ListUniqueProblemsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:uniqueProblems:ListUniqueProblemsResponse' :: Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListUniqueProblemsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | If the number of items that are returned is significantly large, this is
-- an identifier that is also returned. It can be used in a subsequent call
-- to this operation to return the next set of items in the list.
listUniqueProblemsResponse_nextToken :: Lens.Lens' ListUniqueProblemsResponse (Prelude.Maybe Prelude.Text)
listUniqueProblemsResponse_nextToken :: Lens' ListUniqueProblemsResponse (Maybe Text)
listUniqueProblemsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblemsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListUniqueProblemsResponse
s@ListUniqueProblemsResponse' {} Maybe Text
a -> ListUniqueProblemsResponse
s {$sel:nextToken:ListUniqueProblemsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListUniqueProblemsResponse)

-- | Information about the unique problems.
--
-- Allowed values include:
--
-- -   PENDING
--
-- -   PASSED
--
-- -   WARNED
--
-- -   FAILED
--
-- -   SKIPPED
--
-- -   ERRORED
--
-- -   STOPPED
listUniqueProblemsResponse_uniqueProblems :: Lens.Lens' ListUniqueProblemsResponse (Prelude.Maybe (Prelude.HashMap ExecutionResult [UniqueProblem]))
listUniqueProblemsResponse_uniqueProblems :: Lens'
  ListUniqueProblemsResponse
  (Maybe (HashMap ExecutionResult [UniqueProblem]))
listUniqueProblemsResponse_uniqueProblems = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblemsResponse' {Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems :: Maybe (HashMap ExecutionResult [UniqueProblem])
$sel:uniqueProblems:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse
-> Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems} -> Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems) (\s :: ListUniqueProblemsResponse
s@ListUniqueProblemsResponse' {} Maybe (HashMap ExecutionResult [UniqueProblem])
a -> ListUniqueProblemsResponse
s {$sel:uniqueProblems:ListUniqueProblemsResponse' :: Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems = Maybe (HashMap ExecutionResult [UniqueProblem])
a} :: ListUniqueProblemsResponse) 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.
listUniqueProblemsResponse_httpStatus :: Lens.Lens' ListUniqueProblemsResponse Prelude.Int
listUniqueProblemsResponse_httpStatus :: Lens' ListUniqueProblemsResponse Int
listUniqueProblemsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblemsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListUniqueProblemsResponse
s@ListUniqueProblemsResponse' {} Int
a -> ListUniqueProblemsResponse
s {$sel:httpStatus:ListUniqueProblemsResponse' :: Int
httpStatus = Int
a} :: ListUniqueProblemsResponse)

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