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

    -- * Request Lenses
    listAuditMitigationActionsTasks_auditTaskId,
    listAuditMitigationActionsTasks_findingId,
    listAuditMitigationActionsTasks_maxResults,
    listAuditMitigationActionsTasks_nextToken,
    listAuditMitigationActionsTasks_taskStatus,
    listAuditMitigationActionsTasks_startTime,
    listAuditMitigationActionsTasks_endTime,

    -- * Destructuring the Response
    ListAuditMitigationActionsTasksResponse (..),
    newListAuditMitigationActionsTasksResponse,

    -- * Response Lenses
    listAuditMitigationActionsTasksResponse_nextToken,
    listAuditMitigationActionsTasksResponse_tasks,
    listAuditMitigationActionsTasksResponse_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:/ 'newListAuditMitigationActionsTasks' smart constructor.
data ListAuditMitigationActionsTasks = ListAuditMitigationActionsTasks'
  { -- | Specify this filter to limit results to tasks that were applied to
    -- results for a specific audit.
    ListAuditMitigationActionsTasks -> Maybe Text
auditTaskId :: Prelude.Maybe Prelude.Text,
    -- | Specify this filter to limit results to tasks that were applied to a
    -- specific audit finding.
    ListAuditMitigationActionsTasks -> Maybe Text
findingId :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of results to return at one time. The default is 25.
    ListAuditMitigationActionsTasks -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token for the next set of results.
    ListAuditMitigationActionsTasks -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Specify this filter to limit results to tasks that are in a specific
    -- state.
    ListAuditMitigationActionsTasks
-> Maybe AuditMitigationActionsTaskStatus
taskStatus :: Prelude.Maybe AuditMitigationActionsTaskStatus,
    -- | Specify this filter to limit results to tasks that began on or after a
    -- specific date and time.
    ListAuditMitigationActionsTasks -> POSIX
startTime :: Data.POSIX,
    -- | Specify this filter to limit results to tasks that were completed or
    -- canceled on or before a specific date and time.
    ListAuditMitigationActionsTasks -> POSIX
endTime :: Data.POSIX
  }
  deriving (ListAuditMitigationActionsTasks
-> ListAuditMitigationActionsTasks -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListAuditMitigationActionsTasks
-> ListAuditMitigationActionsTasks -> Bool
$c/= :: ListAuditMitigationActionsTasks
-> ListAuditMitigationActionsTasks -> Bool
== :: ListAuditMitigationActionsTasks
-> ListAuditMitigationActionsTasks -> Bool
$c== :: ListAuditMitigationActionsTasks
-> ListAuditMitigationActionsTasks -> Bool
Prelude.Eq, ReadPrec [ListAuditMitigationActionsTasks]
ReadPrec ListAuditMitigationActionsTasks
Int -> ReadS ListAuditMitigationActionsTasks
ReadS [ListAuditMitigationActionsTasks]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListAuditMitigationActionsTasks]
$creadListPrec :: ReadPrec [ListAuditMitigationActionsTasks]
readPrec :: ReadPrec ListAuditMitigationActionsTasks
$creadPrec :: ReadPrec ListAuditMitigationActionsTasks
readList :: ReadS [ListAuditMitigationActionsTasks]
$creadList :: ReadS [ListAuditMitigationActionsTasks]
readsPrec :: Int -> ReadS ListAuditMitigationActionsTasks
$creadsPrec :: Int -> ReadS ListAuditMitigationActionsTasks
Prelude.Read, Int -> ListAuditMitigationActionsTasks -> ShowS
[ListAuditMitigationActionsTasks] -> ShowS
ListAuditMitigationActionsTasks -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListAuditMitigationActionsTasks] -> ShowS
$cshowList :: [ListAuditMitigationActionsTasks] -> ShowS
show :: ListAuditMitigationActionsTasks -> String
$cshow :: ListAuditMitigationActionsTasks -> String
showsPrec :: Int -> ListAuditMitigationActionsTasks -> ShowS
$cshowsPrec :: Int -> ListAuditMitigationActionsTasks -> ShowS
Prelude.Show, forall x.
Rep ListAuditMitigationActionsTasks x
-> ListAuditMitigationActionsTasks
forall x.
ListAuditMitigationActionsTasks
-> Rep ListAuditMitigationActionsTasks x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListAuditMitigationActionsTasks x
-> ListAuditMitigationActionsTasks
$cfrom :: forall x.
ListAuditMitigationActionsTasks
-> Rep ListAuditMitigationActionsTasks x
Prelude.Generic)

-- |
-- Create a value of 'ListAuditMitigationActionsTasks' 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:
--
-- 'auditTaskId', 'listAuditMitigationActionsTasks_auditTaskId' - Specify this filter to limit results to tasks that were applied to
-- results for a specific audit.
--
-- 'findingId', 'listAuditMitigationActionsTasks_findingId' - Specify this filter to limit results to tasks that were applied to a
-- specific audit finding.
--
-- 'maxResults', 'listAuditMitigationActionsTasks_maxResults' - The maximum number of results to return at one time. The default is 25.
--
-- 'nextToken', 'listAuditMitigationActionsTasks_nextToken' - The token for the next set of results.
--
-- 'taskStatus', 'listAuditMitigationActionsTasks_taskStatus' - Specify this filter to limit results to tasks that are in a specific
-- state.
--
-- 'startTime', 'listAuditMitigationActionsTasks_startTime' - Specify this filter to limit results to tasks that began on or after a
-- specific date and time.
--
-- 'endTime', 'listAuditMitigationActionsTasks_endTime' - Specify this filter to limit results to tasks that were completed or
-- canceled on or before a specific date and time.
newListAuditMitigationActionsTasks ::
  -- | 'startTime'
  Prelude.UTCTime ->
  -- | 'endTime'
  Prelude.UTCTime ->
  ListAuditMitigationActionsTasks
newListAuditMitigationActionsTasks :: UTCTime -> UTCTime -> ListAuditMitigationActionsTasks
newListAuditMitigationActionsTasks
  UTCTime
pStartTime_
  UTCTime
pEndTime_ =
    ListAuditMitigationActionsTasks'
      { $sel:auditTaskId:ListAuditMitigationActionsTasks' :: Maybe Text
auditTaskId =
          forall a. Maybe a
Prelude.Nothing,
        $sel:findingId:ListAuditMitigationActionsTasks' :: Maybe Text
findingId = forall a. Maybe a
Prelude.Nothing,
        $sel:maxResults:ListAuditMitigationActionsTasks' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
        $sel:nextToken:ListAuditMitigationActionsTasks' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
        $sel:taskStatus:ListAuditMitigationActionsTasks' :: Maybe AuditMitigationActionsTaskStatus
taskStatus = forall a. Maybe a
Prelude.Nothing,
        $sel:startTime:ListAuditMitigationActionsTasks' :: POSIX
startTime = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pStartTime_,
        $sel:endTime:ListAuditMitigationActionsTasks' :: POSIX
endTime = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pEndTime_
      }

-- | Specify this filter to limit results to tasks that were applied to
-- results for a specific audit.
listAuditMitigationActionsTasks_auditTaskId :: Lens.Lens' ListAuditMitigationActionsTasks (Prelude.Maybe Prelude.Text)
listAuditMitigationActionsTasks_auditTaskId :: Lens' ListAuditMitigationActionsTasks (Maybe Text)
listAuditMitigationActionsTasks_auditTaskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsTasks' {Maybe Text
auditTaskId :: Maybe Text
$sel:auditTaskId:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
auditTaskId} -> Maybe Text
auditTaskId) (\s :: ListAuditMitigationActionsTasks
s@ListAuditMitigationActionsTasks' {} Maybe Text
a -> ListAuditMitigationActionsTasks
s {$sel:auditTaskId:ListAuditMitigationActionsTasks' :: Maybe Text
auditTaskId = Maybe Text
a} :: ListAuditMitigationActionsTasks)

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

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

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

-- | Specify this filter to limit results to tasks that are in a specific
-- state.
listAuditMitigationActionsTasks_taskStatus :: Lens.Lens' ListAuditMitigationActionsTasks (Prelude.Maybe AuditMitigationActionsTaskStatus)
listAuditMitigationActionsTasks_taskStatus :: Lens'
  ListAuditMitigationActionsTasks
  (Maybe AuditMitigationActionsTaskStatus)
listAuditMitigationActionsTasks_taskStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsTasks' {Maybe AuditMitigationActionsTaskStatus
taskStatus :: Maybe AuditMitigationActionsTaskStatus
$sel:taskStatus:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks
-> Maybe AuditMitigationActionsTaskStatus
taskStatus} -> Maybe AuditMitigationActionsTaskStatus
taskStatus) (\s :: ListAuditMitigationActionsTasks
s@ListAuditMitigationActionsTasks' {} Maybe AuditMitigationActionsTaskStatus
a -> ListAuditMitigationActionsTasks
s {$sel:taskStatus:ListAuditMitigationActionsTasks' :: Maybe AuditMitigationActionsTaskStatus
taskStatus = Maybe AuditMitigationActionsTaskStatus
a} :: ListAuditMitigationActionsTasks)

-- | Specify this filter to limit results to tasks that began on or after a
-- specific date and time.
listAuditMitigationActionsTasks_startTime :: Lens.Lens' ListAuditMitigationActionsTasks Prelude.UTCTime
listAuditMitigationActionsTasks_startTime :: Lens' ListAuditMitigationActionsTasks UTCTime
listAuditMitigationActionsTasks_startTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsTasks' {POSIX
startTime :: POSIX
$sel:startTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
startTime} -> POSIX
startTime) (\s :: ListAuditMitigationActionsTasks
s@ListAuditMitigationActionsTasks' {} POSIX
a -> ListAuditMitigationActionsTasks
s {$sel:startTime:ListAuditMitigationActionsTasks' :: POSIX
startTime = POSIX
a} :: ListAuditMitigationActionsTasks) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Specify this filter to limit results to tasks that were completed or
-- canceled on or before a specific date and time.
listAuditMitigationActionsTasks_endTime :: Lens.Lens' ListAuditMitigationActionsTasks Prelude.UTCTime
listAuditMitigationActionsTasks_endTime :: Lens' ListAuditMitigationActionsTasks UTCTime
listAuditMitigationActionsTasks_endTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsTasks' {POSIX
endTime :: POSIX
$sel:endTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
endTime} -> POSIX
endTime) (\s :: ListAuditMitigationActionsTasks
s@ListAuditMitigationActionsTasks' {} POSIX
a -> ListAuditMitigationActionsTasks
s {$sel:endTime:ListAuditMitigationActionsTasks' :: POSIX
endTime = POSIX
a} :: ListAuditMitigationActionsTasks) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

instance
  Core.AWSPager
    ListAuditMitigationActionsTasks
  where
  page :: ListAuditMitigationActionsTasks
-> AWSResponse ListAuditMitigationActionsTasks
-> Maybe ListAuditMitigationActionsTasks
page ListAuditMitigationActionsTasks
rq AWSResponse ListAuditMitigationActionsTasks
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListAuditMitigationActionsTasks
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListAuditMitigationActionsTasksResponse (Maybe Text)
listAuditMitigationActionsTasksResponse_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 ListAuditMitigationActionsTasks
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
  ListAuditMitigationActionsTasksResponse
  (Maybe [AuditMitigationActionsTaskMetadata])
listAuditMitigationActionsTasksResponse_tasks
            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.$ ListAuditMitigationActionsTasks
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListAuditMitigationActionsTasks (Maybe Text)
listAuditMitigationActionsTasks_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListAuditMitigationActionsTasks
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListAuditMitigationActionsTasksResponse (Maybe Text)
listAuditMitigationActionsTasksResponse_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
    ListAuditMitigationActionsTasks
  where
  type
    AWSResponse ListAuditMitigationActionsTasks =
      ListAuditMitigationActionsTasksResponse
  request :: (Service -> Service)
-> ListAuditMitigationActionsTasks
-> Request ListAuditMitigationActionsTasks
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 ListAuditMitigationActionsTasks
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse ListAuditMitigationActionsTasks)))
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 [AuditMitigationActionsTaskMetadata]
-> Int
-> ListAuditMitigationActionsTasksResponse
ListAuditMitigationActionsTasksResponse'
            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
"tasks" 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
    ListAuditMitigationActionsTasks
  where
  hashWithSalt :: Int -> ListAuditMitigationActionsTasks -> Int
hashWithSalt
    Int
_salt
    ListAuditMitigationActionsTasks' {Maybe Natural
Maybe Text
Maybe AuditMitigationActionsTaskStatus
POSIX
endTime :: POSIX
startTime :: POSIX
taskStatus :: Maybe AuditMitigationActionsTaskStatus
nextToken :: Maybe Text
maxResults :: Maybe Natural
findingId :: Maybe Text
auditTaskId :: Maybe Text
$sel:endTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
$sel:startTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
$sel:taskStatus:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks
-> Maybe AuditMitigationActionsTaskStatus
$sel:nextToken:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
$sel:maxResults:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Natural
$sel:findingId:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
$sel:auditTaskId:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
auditTaskId
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
findingId
        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` Maybe AuditMitigationActionsTaskStatus
taskStatus
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
startTime
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
endTime

instance
  Prelude.NFData
    ListAuditMitigationActionsTasks
  where
  rnf :: ListAuditMitigationActionsTasks -> ()
rnf ListAuditMitigationActionsTasks' {Maybe Natural
Maybe Text
Maybe AuditMitigationActionsTaskStatus
POSIX
endTime :: POSIX
startTime :: POSIX
taskStatus :: Maybe AuditMitigationActionsTaskStatus
nextToken :: Maybe Text
maxResults :: Maybe Natural
findingId :: Maybe Text
auditTaskId :: Maybe Text
$sel:endTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
$sel:startTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
$sel:taskStatus:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks
-> Maybe AuditMitigationActionsTaskStatus
$sel:nextToken:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
$sel:maxResults:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Natural
$sel:findingId:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
$sel:auditTaskId:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
auditTaskId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
findingId
      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 Maybe AuditMitigationActionsTaskStatus
taskStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
startTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
endTime

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

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

instance Data.ToQuery ListAuditMitigationActionsTasks where
  toQuery :: ListAuditMitigationActionsTasks -> QueryString
toQuery ListAuditMitigationActionsTasks' {Maybe Natural
Maybe Text
Maybe AuditMitigationActionsTaskStatus
POSIX
endTime :: POSIX
startTime :: POSIX
taskStatus :: Maybe AuditMitigationActionsTaskStatus
nextToken :: Maybe Text
maxResults :: Maybe Natural
findingId :: Maybe Text
auditTaskId :: Maybe Text
$sel:endTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
$sel:startTime:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> POSIX
$sel:taskStatus:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks
-> Maybe AuditMitigationActionsTaskStatus
$sel:nextToken:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
$sel:maxResults:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Natural
$sel:findingId:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
$sel:auditTaskId:ListAuditMitigationActionsTasks' :: ListAuditMitigationActionsTasks -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"auditTaskId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
auditTaskId,
        ByteString
"findingId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
findingId,
        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
"taskStatus" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe AuditMitigationActionsTaskStatus
taskStatus,
        ByteString
"startTime" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: POSIX
startTime,
        ByteString
"endTime" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: POSIX
endTime
      ]

-- | /See:/ 'newListAuditMitigationActionsTasksResponse' smart constructor.
data ListAuditMitigationActionsTasksResponse = ListAuditMitigationActionsTasksResponse'
  { -- | The token for the next set of results.
    ListAuditMitigationActionsTasksResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The collection of audit mitigation tasks that matched the filter
    -- criteria.
    ListAuditMitigationActionsTasksResponse
-> Maybe [AuditMitigationActionsTaskMetadata]
tasks :: Prelude.Maybe [AuditMitigationActionsTaskMetadata],
    -- | The response's http status code.
    ListAuditMitigationActionsTasksResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListAuditMitigationActionsTasksResponse
-> ListAuditMitigationActionsTasksResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListAuditMitigationActionsTasksResponse
-> ListAuditMitigationActionsTasksResponse -> Bool
$c/= :: ListAuditMitigationActionsTasksResponse
-> ListAuditMitigationActionsTasksResponse -> Bool
== :: ListAuditMitigationActionsTasksResponse
-> ListAuditMitigationActionsTasksResponse -> Bool
$c== :: ListAuditMitigationActionsTasksResponse
-> ListAuditMitigationActionsTasksResponse -> Bool
Prelude.Eq, ReadPrec [ListAuditMitigationActionsTasksResponse]
ReadPrec ListAuditMitigationActionsTasksResponse
Int -> ReadS ListAuditMitigationActionsTasksResponse
ReadS [ListAuditMitigationActionsTasksResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListAuditMitigationActionsTasksResponse]
$creadListPrec :: ReadPrec [ListAuditMitigationActionsTasksResponse]
readPrec :: ReadPrec ListAuditMitigationActionsTasksResponse
$creadPrec :: ReadPrec ListAuditMitigationActionsTasksResponse
readList :: ReadS [ListAuditMitigationActionsTasksResponse]
$creadList :: ReadS [ListAuditMitigationActionsTasksResponse]
readsPrec :: Int -> ReadS ListAuditMitigationActionsTasksResponse
$creadsPrec :: Int -> ReadS ListAuditMitigationActionsTasksResponse
Prelude.Read, Int -> ListAuditMitigationActionsTasksResponse -> ShowS
[ListAuditMitigationActionsTasksResponse] -> ShowS
ListAuditMitigationActionsTasksResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListAuditMitigationActionsTasksResponse] -> ShowS
$cshowList :: [ListAuditMitigationActionsTasksResponse] -> ShowS
show :: ListAuditMitigationActionsTasksResponse -> String
$cshow :: ListAuditMitigationActionsTasksResponse -> String
showsPrec :: Int -> ListAuditMitigationActionsTasksResponse -> ShowS
$cshowsPrec :: Int -> ListAuditMitigationActionsTasksResponse -> ShowS
Prelude.Show, forall x.
Rep ListAuditMitigationActionsTasksResponse x
-> ListAuditMitigationActionsTasksResponse
forall x.
ListAuditMitigationActionsTasksResponse
-> Rep ListAuditMitigationActionsTasksResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListAuditMitigationActionsTasksResponse x
-> ListAuditMitigationActionsTasksResponse
$cfrom :: forall x.
ListAuditMitigationActionsTasksResponse
-> Rep ListAuditMitigationActionsTasksResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListAuditMitigationActionsTasksResponse' 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', 'listAuditMitigationActionsTasksResponse_nextToken' - The token for the next set of results.
--
-- 'tasks', 'listAuditMitigationActionsTasksResponse_tasks' - The collection of audit mitigation tasks that matched the filter
-- criteria.
--
-- 'httpStatus', 'listAuditMitigationActionsTasksResponse_httpStatus' - The response's http status code.
newListAuditMitigationActionsTasksResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListAuditMitigationActionsTasksResponse
newListAuditMitigationActionsTasksResponse :: Int -> ListAuditMitigationActionsTasksResponse
newListAuditMitigationActionsTasksResponse
  Int
pHttpStatus_ =
    ListAuditMitigationActionsTasksResponse'
      { $sel:nextToken:ListAuditMitigationActionsTasksResponse' :: Maybe Text
nextToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:tasks:ListAuditMitigationActionsTasksResponse' :: Maybe [AuditMitigationActionsTaskMetadata]
tasks = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:ListAuditMitigationActionsTasksResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

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

-- | The collection of audit mitigation tasks that matched the filter
-- criteria.
listAuditMitigationActionsTasksResponse_tasks :: Lens.Lens' ListAuditMitigationActionsTasksResponse (Prelude.Maybe [AuditMitigationActionsTaskMetadata])
listAuditMitigationActionsTasksResponse_tasks :: Lens'
  ListAuditMitigationActionsTasksResponse
  (Maybe [AuditMitigationActionsTaskMetadata])
listAuditMitigationActionsTasksResponse_tasks = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsTasksResponse' {Maybe [AuditMitigationActionsTaskMetadata]
tasks :: Maybe [AuditMitigationActionsTaskMetadata]
$sel:tasks:ListAuditMitigationActionsTasksResponse' :: ListAuditMitigationActionsTasksResponse
-> Maybe [AuditMitigationActionsTaskMetadata]
tasks} -> Maybe [AuditMitigationActionsTaskMetadata]
tasks) (\s :: ListAuditMitigationActionsTasksResponse
s@ListAuditMitigationActionsTasksResponse' {} Maybe [AuditMitigationActionsTaskMetadata]
a -> ListAuditMitigationActionsTasksResponse
s {$sel:tasks:ListAuditMitigationActionsTasksResponse' :: Maybe [AuditMitigationActionsTaskMetadata]
tasks = Maybe [AuditMitigationActionsTaskMetadata]
a} :: ListAuditMitigationActionsTasksResponse) 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.
listAuditMitigationActionsTasksResponse_httpStatus :: Lens.Lens' ListAuditMitigationActionsTasksResponse Prelude.Int
listAuditMitigationActionsTasksResponse_httpStatus :: Lens' ListAuditMitigationActionsTasksResponse Int
listAuditMitigationActionsTasksResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListAuditMitigationActionsTasksResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListAuditMitigationActionsTasksResponse' :: ListAuditMitigationActionsTasksResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListAuditMitigationActionsTasksResponse
s@ListAuditMitigationActionsTasksResponse' {} Int
a -> ListAuditMitigationActionsTasksResponse
s {$sel:httpStatus:ListAuditMitigationActionsTasksResponse' :: Int
httpStatus = Int
a} :: ListAuditMitigationActionsTasksResponse)

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