{-# 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.IoT.ListAuditMitigationActionsExecutions
-- 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 the status of audit mitigation action tasks that were executed.
--
-- Requires permission to access the
-- <https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiot.html#awsiot-actions-as-permissions ListAuditMitigationActionsExecutions>
-- action.
--
-- This operation returns paginated results.
module Amazonka.IoT.ListAuditMitigationActionsExecutions
  ( -- * Creating a Request
    ListAuditMitigationActionsExecutions (..),
    newListAuditMitigationActionsExecutions,

    -- * Request Lenses
    listAuditMitigationActionsExecutions_actionStatus,
    listAuditMitigationActionsExecutions_maxResults,
    listAuditMitigationActionsExecutions_nextToken,
    listAuditMitigationActionsExecutions_taskId,
    listAuditMitigationActionsExecutions_findingId,

    -- * Destructuring the Response
    ListAuditMitigationActionsExecutionsResponse (..),
    newListAuditMitigationActionsExecutionsResponse,

    -- * Response Lenses
    listAuditMitigationActionsExecutionsResponse_actionsExecutions,
    listAuditMitigationActionsExecutionsResponse_nextToken,
    listAuditMitigationActionsExecutionsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListAuditMitigationActionsExecutions' smart constructor.
data ListAuditMitigationActionsExecutions = ListAuditMitigationActionsExecutions'
  { -- | Specify this filter to limit results to those with a specific status.
    ListAuditMitigationActionsExecutions
-> Maybe AuditMitigationActionsExecutionStatus
actionStatus :: Prelude.Maybe AuditMitigationActionsExecutionStatus,
    -- | The maximum number of results to return at one time. The default is 25.
    ListAuditMitigationActionsExecutions -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token for the next set of results.
    ListAuditMitigationActionsExecutions -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Specify this filter to limit results to actions for a specific audit
    -- mitigation actions task.
    ListAuditMitigationActionsExecutions -> Text
taskId :: Prelude.Text,
    -- | Specify this filter to limit results to those that were applied to a
    -- specific audit finding.
    ListAuditMitigationActionsExecutions -> Text
findingId :: Prelude.Text
  }
  deriving (ListAuditMitigationActionsExecutions
-> ListAuditMitigationActionsExecutions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListAuditMitigationActionsExecutions
-> ListAuditMitigationActionsExecutions -> Bool
$c/= :: ListAuditMitigationActionsExecutions
-> ListAuditMitigationActionsExecutions -> Bool
== :: ListAuditMitigationActionsExecutions
-> ListAuditMitigationActionsExecutions -> Bool
$c== :: ListAuditMitigationActionsExecutions
-> ListAuditMitigationActionsExecutions -> Bool
Prelude.Eq, ReadPrec [ListAuditMitigationActionsExecutions]
ReadPrec ListAuditMitigationActionsExecutions
Int -> ReadS ListAuditMitigationActionsExecutions
ReadS [ListAuditMitigationActionsExecutions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListAuditMitigationActionsExecutions]
$creadListPrec :: ReadPrec [ListAuditMitigationActionsExecutions]
readPrec :: ReadPrec ListAuditMitigationActionsExecutions
$creadPrec :: ReadPrec ListAuditMitigationActionsExecutions
readList :: ReadS [ListAuditMitigationActionsExecutions]
$creadList :: ReadS [ListAuditMitigationActionsExecutions]
readsPrec :: Int -> ReadS ListAuditMitigationActionsExecutions
$creadsPrec :: Int -> ReadS ListAuditMitigationActionsExecutions
Prelude.Read, Int -> ListAuditMitigationActionsExecutions -> ShowS
[ListAuditMitigationActionsExecutions] -> ShowS
ListAuditMitigationActionsExecutions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListAuditMitigationActionsExecutions] -> ShowS
$cshowList :: [ListAuditMitigationActionsExecutions] -> ShowS
show :: ListAuditMitigationActionsExecutions -> String
$cshow :: ListAuditMitigationActionsExecutions -> String
showsPrec :: Int -> ListAuditMitigationActionsExecutions -> ShowS
$cshowsPrec :: Int -> ListAuditMitigationActionsExecutions -> ShowS
Prelude.Show, forall x.
Rep ListAuditMitigationActionsExecutions x
-> ListAuditMitigationActionsExecutions
forall x.
ListAuditMitigationActionsExecutions
-> Rep ListAuditMitigationActionsExecutions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListAuditMitigationActionsExecutions x
-> ListAuditMitigationActionsExecutions
$cfrom :: forall x.
ListAuditMitigationActionsExecutions
-> Rep ListAuditMitigationActionsExecutions x
Prelude.Generic)

-- |
-- Create a value of 'ListAuditMitigationActionsExecutions' 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:
--
-- 'actionStatus', 'listAuditMitigationActionsExecutions_actionStatus' - Specify this filter to limit results to those with a specific status.
--
-- 'maxResults', 'listAuditMitigationActionsExecutions_maxResults' - The maximum number of results to return at one time. The default is 25.
--
-- 'nextToken', 'listAuditMitigationActionsExecutions_nextToken' - The token for the next set of results.
--
-- 'taskId', 'listAuditMitigationActionsExecutions_taskId' - Specify this filter to limit results to actions for a specific audit
-- mitigation actions task.
--
-- 'findingId', 'listAuditMitigationActionsExecutions_findingId' - Specify this filter to limit results to those that were applied to a
-- specific audit finding.
newListAuditMitigationActionsExecutions ::
  -- | 'taskId'
  Prelude.Text ->
  -- | 'findingId'
  Prelude.Text ->
  ListAuditMitigationActionsExecutions
newListAuditMitigationActionsExecutions :: Text -> Text -> ListAuditMitigationActionsExecutions
newListAuditMitigationActionsExecutions
  Text
pTaskId_
  Text
pFindingId_ =
    ListAuditMitigationActionsExecutions'
      { $sel:actionStatus:ListAuditMitigationActionsExecutions' :: Maybe AuditMitigationActionsExecutionStatus
actionStatus =
          forall a. Maybe a
Prelude.Nothing,
        $sel:maxResults:ListAuditMitigationActionsExecutions' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListAuditMitigationActionsExecutions' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:taskId:ListAuditMitigationActionsExecutions' :: Text
taskId = Text
pTaskId_,
        $sel:findingId:ListAuditMitigationActionsExecutions' :: Text
findingId = Text
pFindingId_
      }

-- | Specify this filter to limit results to those with a specific status.
listAuditMitigationActionsExecutions_actionStatus :: Lens.Lens' ListAuditMitigationActionsExecutions (Prelude.Maybe AuditMitigationActionsExecutionStatus)
listAuditMitigationActionsExecutions_actionStatus :: Lens'
  ListAuditMitigationActionsExecutions
  (Maybe AuditMitigationActionsExecutionStatus)
listAuditMitigationActionsExecutions_actionStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsExecutions' {Maybe AuditMitigationActionsExecutionStatus
actionStatus :: Maybe AuditMitigationActionsExecutionStatus
$sel:actionStatus:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions
-> Maybe AuditMitigationActionsExecutionStatus
actionStatus} -> Maybe AuditMitigationActionsExecutionStatus
actionStatus) (\s :: ListAuditMitigationActionsExecutions
s@ListAuditMitigationActionsExecutions' {} Maybe AuditMitigationActionsExecutionStatus
a -> ListAuditMitigationActionsExecutions
s {$sel:actionStatus:ListAuditMitigationActionsExecutions' :: Maybe AuditMitigationActionsExecutionStatus
actionStatus = Maybe AuditMitigationActionsExecutionStatus
a} :: ListAuditMitigationActionsExecutions)

-- | The maximum number of results to return at one time. The default is 25.
listAuditMitigationActionsExecutions_maxResults :: Lens.Lens' ListAuditMitigationActionsExecutions (Prelude.Maybe Prelude.Natural)
listAuditMitigationActionsExecutions_maxResults :: Lens' ListAuditMitigationActionsExecutions (Maybe Natural)
listAuditMitigationActionsExecutions_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsExecutions' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListAuditMitigationActionsExecutions
s@ListAuditMitigationActionsExecutions' {} Maybe Natural
a -> ListAuditMitigationActionsExecutions
s {$sel:maxResults:ListAuditMitigationActionsExecutions' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListAuditMitigationActionsExecutions)

-- | The token for the next set of results.
listAuditMitigationActionsExecutions_nextToken :: Lens.Lens' ListAuditMitigationActionsExecutions (Prelude.Maybe Prelude.Text)
listAuditMitigationActionsExecutions_nextToken :: Lens' ListAuditMitigationActionsExecutions (Maybe Text)
listAuditMitigationActionsExecutions_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsExecutions' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListAuditMitigationActionsExecutions
s@ListAuditMitigationActionsExecutions' {} Maybe Text
a -> ListAuditMitigationActionsExecutions
s {$sel:nextToken:ListAuditMitigationActionsExecutions' :: Maybe Text
nextToken = Maybe Text
a} :: ListAuditMitigationActionsExecutions)

-- | Specify this filter to limit results to actions for a specific audit
-- mitigation actions task.
listAuditMitigationActionsExecutions_taskId :: Lens.Lens' ListAuditMitigationActionsExecutions Prelude.Text
listAuditMitigationActionsExecutions_taskId :: Lens' ListAuditMitigationActionsExecutions Text
listAuditMitigationActionsExecutions_taskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsExecutions' {Text
taskId :: Text
$sel:taskId:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Text
taskId} -> Text
taskId) (\s :: ListAuditMitigationActionsExecutions
s@ListAuditMitigationActionsExecutions' {} Text
a -> ListAuditMitigationActionsExecutions
s {$sel:taskId:ListAuditMitigationActionsExecutions' :: Text
taskId = Text
a} :: ListAuditMitigationActionsExecutions)

-- | Specify this filter to limit results to those that were applied to a
-- specific audit finding.
listAuditMitigationActionsExecutions_findingId :: Lens.Lens' ListAuditMitigationActionsExecutions Prelude.Text
listAuditMitigationActionsExecutions_findingId :: Lens' ListAuditMitigationActionsExecutions Text
listAuditMitigationActionsExecutions_findingId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsExecutions' {Text
findingId :: Text
$sel:findingId:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Text
findingId} -> Text
findingId) (\s :: ListAuditMitigationActionsExecutions
s@ListAuditMitigationActionsExecutions' {} Text
a -> ListAuditMitigationActionsExecutions
s {$sel:findingId:ListAuditMitigationActionsExecutions' :: Text
findingId = Text
a} :: ListAuditMitigationActionsExecutions)

instance
  Core.AWSPager
    ListAuditMitigationActionsExecutions
  where
  page :: ListAuditMitigationActionsExecutions
-> AWSResponse ListAuditMitigationActionsExecutions
-> Maybe ListAuditMitigationActionsExecutions
page ListAuditMitigationActionsExecutions
rq AWSResponse ListAuditMitigationActionsExecutions
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListAuditMitigationActionsExecutions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListAuditMitigationActionsExecutionsResponse (Maybe Text)
listAuditMitigationActionsExecutionsResponse_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 ListAuditMitigationActionsExecutions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListAuditMitigationActionsExecutionsResponse
  (Maybe [AuditMitigationActionExecutionMetadata])
listAuditMitigationActionsExecutionsResponse_actionsExecutions
            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.$ ListAuditMitigationActionsExecutions
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListAuditMitigationActionsExecutions (Maybe Text)
listAuditMitigationActionsExecutions_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListAuditMitigationActionsExecutions
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListAuditMitigationActionsExecutionsResponse (Maybe Text)
listAuditMitigationActionsExecutionsResponse_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
    ListAuditMitigationActionsExecutions
  where
  type
    AWSResponse ListAuditMitigationActionsExecutions =
      ListAuditMitigationActionsExecutionsResponse
  request :: (Service -> Service)
-> ListAuditMitigationActionsExecutions
-> Request ListAuditMitigationActionsExecutions
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 ListAuditMitigationActionsExecutions
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse
           (AWSResponse ListAuditMitigationActionsExecutions)))
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 [AuditMitigationActionExecutionMetadata]
-> Maybe Text
-> Int
-> ListAuditMitigationActionsExecutionsResponse
ListAuditMitigationActionsExecutionsResponse'
            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
"actionsExecutions"
                            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
    ListAuditMitigationActionsExecutions
  where
  hashWithSalt :: Int -> ListAuditMitigationActionsExecutions -> Int
hashWithSalt
    Int
_salt
    ListAuditMitigationActionsExecutions' {Maybe Natural
Maybe Text
Maybe AuditMitigationActionsExecutionStatus
Text
findingId :: Text
taskId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
actionStatus :: Maybe AuditMitigationActionsExecutionStatus
$sel:findingId:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Text
$sel:taskId:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Text
$sel:nextToken:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Maybe Text
$sel:maxResults:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Maybe Natural
$sel:actionStatus:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions
-> Maybe AuditMitigationActionsExecutionStatus
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AuditMitigationActionsExecutionStatus
actionStatus
        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
taskId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
findingId

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

instance
  Data.ToHeaders
    ListAuditMitigationActionsExecutions
  where
  toHeaders :: ListAuditMitigationActionsExecutions -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance
  Data.ToPath
    ListAuditMitigationActionsExecutions
  where
  toPath :: ListAuditMitigationActionsExecutions -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const ByteString
"/audit/mitigationactions/executions"

instance
  Data.ToQuery
    ListAuditMitigationActionsExecutions
  where
  toQuery :: ListAuditMitigationActionsExecutions -> QueryString
toQuery ListAuditMitigationActionsExecutions' {Maybe Natural
Maybe Text
Maybe AuditMitigationActionsExecutionStatus
Text
findingId :: Text
taskId :: Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
actionStatus :: Maybe AuditMitigationActionsExecutionStatus
$sel:findingId:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Text
$sel:taskId:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Text
$sel:nextToken:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Maybe Text
$sel:maxResults:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions -> Maybe Natural
$sel:actionStatus:ListAuditMitigationActionsExecutions' :: ListAuditMitigationActionsExecutions
-> Maybe AuditMitigationActionsExecutionStatus
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"actionStatus" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe AuditMitigationActionsExecutionStatus
actionStatus,
        ByteString
"maxResults" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Natural
maxResults,
        ByteString
"nextToken" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
nextToken,
        ByteString
"taskId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
taskId,
        ByteString
"findingId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
findingId
      ]

-- | /See:/ 'newListAuditMitigationActionsExecutionsResponse' smart constructor.
data ListAuditMitigationActionsExecutionsResponse = ListAuditMitigationActionsExecutionsResponse'
  { -- | A set of task execution results based on the input parameters. Details
    -- include the mitigation action applied, start time, and task status.
    ListAuditMitigationActionsExecutionsResponse
-> Maybe [AuditMitigationActionExecutionMetadata]
actionsExecutions :: Prelude.Maybe [AuditMitigationActionExecutionMetadata],
    -- | The token for the next set of results.
    ListAuditMitigationActionsExecutionsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListAuditMitigationActionsExecutionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListAuditMitigationActionsExecutionsResponse
-> ListAuditMitigationActionsExecutionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListAuditMitigationActionsExecutionsResponse
-> ListAuditMitigationActionsExecutionsResponse -> Bool
$c/= :: ListAuditMitigationActionsExecutionsResponse
-> ListAuditMitigationActionsExecutionsResponse -> Bool
== :: ListAuditMitigationActionsExecutionsResponse
-> ListAuditMitigationActionsExecutionsResponse -> Bool
$c== :: ListAuditMitigationActionsExecutionsResponse
-> ListAuditMitigationActionsExecutionsResponse -> Bool
Prelude.Eq, ReadPrec [ListAuditMitigationActionsExecutionsResponse]
ReadPrec ListAuditMitigationActionsExecutionsResponse
Int -> ReadS ListAuditMitigationActionsExecutionsResponse
ReadS [ListAuditMitigationActionsExecutionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListAuditMitigationActionsExecutionsResponse]
$creadListPrec :: ReadPrec [ListAuditMitigationActionsExecutionsResponse]
readPrec :: ReadPrec ListAuditMitigationActionsExecutionsResponse
$creadPrec :: ReadPrec ListAuditMitigationActionsExecutionsResponse
readList :: ReadS [ListAuditMitigationActionsExecutionsResponse]
$creadList :: ReadS [ListAuditMitigationActionsExecutionsResponse]
readsPrec :: Int -> ReadS ListAuditMitigationActionsExecutionsResponse
$creadsPrec :: Int -> ReadS ListAuditMitigationActionsExecutionsResponse
Prelude.Read, Int -> ListAuditMitigationActionsExecutionsResponse -> ShowS
[ListAuditMitigationActionsExecutionsResponse] -> ShowS
ListAuditMitigationActionsExecutionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListAuditMitigationActionsExecutionsResponse] -> ShowS
$cshowList :: [ListAuditMitigationActionsExecutionsResponse] -> ShowS
show :: ListAuditMitigationActionsExecutionsResponse -> String
$cshow :: ListAuditMitigationActionsExecutionsResponse -> String
showsPrec :: Int -> ListAuditMitigationActionsExecutionsResponse -> ShowS
$cshowsPrec :: Int -> ListAuditMitigationActionsExecutionsResponse -> ShowS
Prelude.Show, forall x.
Rep ListAuditMitigationActionsExecutionsResponse x
-> ListAuditMitigationActionsExecutionsResponse
forall x.
ListAuditMitigationActionsExecutionsResponse
-> Rep ListAuditMitigationActionsExecutionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListAuditMitigationActionsExecutionsResponse x
-> ListAuditMitigationActionsExecutionsResponse
$cfrom :: forall x.
ListAuditMitigationActionsExecutionsResponse
-> Rep ListAuditMitigationActionsExecutionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListAuditMitigationActionsExecutionsResponse' 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:
--
-- 'actionsExecutions', 'listAuditMitigationActionsExecutionsResponse_actionsExecutions' - A set of task execution results based on the input parameters. Details
-- include the mitigation action applied, start time, and task status.
--
-- 'nextToken', 'listAuditMitigationActionsExecutionsResponse_nextToken' - The token for the next set of results.
--
-- 'httpStatus', 'listAuditMitigationActionsExecutionsResponse_httpStatus' - The response's http status code.
newListAuditMitigationActionsExecutionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListAuditMitigationActionsExecutionsResponse
newListAuditMitigationActionsExecutionsResponse :: Int -> ListAuditMitigationActionsExecutionsResponse
newListAuditMitigationActionsExecutionsResponse
  Int
pHttpStatus_ =
    ListAuditMitigationActionsExecutionsResponse'
      { $sel:actionsExecutions:ListAuditMitigationActionsExecutionsResponse' :: Maybe [AuditMitigationActionExecutionMetadata]
actionsExecutions =
          forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListAuditMitigationActionsExecutionsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:ListAuditMitigationActionsExecutionsResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | A set of task execution results based on the input parameters. Details
-- include the mitigation action applied, start time, and task status.
listAuditMitigationActionsExecutionsResponse_actionsExecutions :: Lens.Lens' ListAuditMitigationActionsExecutionsResponse (Prelude.Maybe [AuditMitigationActionExecutionMetadata])
listAuditMitigationActionsExecutionsResponse_actionsExecutions :: Lens'
  ListAuditMitigationActionsExecutionsResponse
  (Maybe [AuditMitigationActionExecutionMetadata])
listAuditMitigationActionsExecutionsResponse_actionsExecutions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsExecutionsResponse' {Maybe [AuditMitigationActionExecutionMetadata]
actionsExecutions :: Maybe [AuditMitigationActionExecutionMetadata]
$sel:actionsExecutions:ListAuditMitigationActionsExecutionsResponse' :: ListAuditMitigationActionsExecutionsResponse
-> Maybe [AuditMitigationActionExecutionMetadata]
actionsExecutions} -> Maybe [AuditMitigationActionExecutionMetadata]
actionsExecutions) (\s :: ListAuditMitigationActionsExecutionsResponse
s@ListAuditMitigationActionsExecutionsResponse' {} Maybe [AuditMitigationActionExecutionMetadata]
a -> ListAuditMitigationActionsExecutionsResponse
s {$sel:actionsExecutions:ListAuditMitigationActionsExecutionsResponse' :: Maybe [AuditMitigationActionExecutionMetadata]
actionsExecutions = Maybe [AuditMitigationActionExecutionMetadata]
a} :: ListAuditMitigationActionsExecutionsResponse) 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 for the next set of results.
listAuditMitigationActionsExecutionsResponse_nextToken :: Lens.Lens' ListAuditMitigationActionsExecutionsResponse (Prelude.Maybe Prelude.Text)
listAuditMitigationActionsExecutionsResponse_nextToken :: Lens' ListAuditMitigationActionsExecutionsResponse (Maybe Text)
listAuditMitigationActionsExecutionsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsExecutionsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListAuditMitigationActionsExecutionsResponse' :: ListAuditMitigationActionsExecutionsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListAuditMitigationActionsExecutionsResponse
s@ListAuditMitigationActionsExecutionsResponse' {} Maybe Text
a -> ListAuditMitigationActionsExecutionsResponse
s {$sel:nextToken:ListAuditMitigationActionsExecutionsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListAuditMitigationActionsExecutionsResponse)

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

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