{-# 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.DescribeAuditMitigationActionsTask
-- 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 an audit mitigation task that is used to apply
-- mitigation actions to a set of audit findings. Properties include the
-- actions being applied, the audit checks to which they\'re being applied,
-- the task status, and aggregated task statistics.
module Amazonka.IoT.DescribeAuditMitigationActionsTask
  ( -- * Creating a Request
    DescribeAuditMitigationActionsTask (..),
    newDescribeAuditMitigationActionsTask,

    -- * Request Lenses
    describeAuditMitigationActionsTask_taskId,

    -- * Destructuring the Response
    DescribeAuditMitigationActionsTaskResponse (..),
    newDescribeAuditMitigationActionsTaskResponse,

    -- * Response Lenses
    describeAuditMitigationActionsTaskResponse_actionsDefinition,
    describeAuditMitigationActionsTaskResponse_auditCheckToActionsMapping,
    describeAuditMitigationActionsTaskResponse_endTime,
    describeAuditMitigationActionsTaskResponse_startTime,
    describeAuditMitigationActionsTaskResponse_target,
    describeAuditMitigationActionsTaskResponse_taskStatistics,
    describeAuditMitigationActionsTaskResponse_taskStatus,
    describeAuditMitigationActionsTaskResponse_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:/ 'newDescribeAuditMitigationActionsTask' smart constructor.
data DescribeAuditMitigationActionsTask = DescribeAuditMitigationActionsTask'
  { -- | The unique identifier for the audit mitigation task.
    DescribeAuditMitigationActionsTask -> Text
taskId :: Prelude.Text
  }
  deriving (DescribeAuditMitigationActionsTask
-> DescribeAuditMitigationActionsTask -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeAuditMitigationActionsTask
-> DescribeAuditMitigationActionsTask -> Bool
$c/= :: DescribeAuditMitigationActionsTask
-> DescribeAuditMitigationActionsTask -> Bool
== :: DescribeAuditMitigationActionsTask
-> DescribeAuditMitigationActionsTask -> Bool
$c== :: DescribeAuditMitigationActionsTask
-> DescribeAuditMitigationActionsTask -> Bool
Prelude.Eq, ReadPrec [DescribeAuditMitigationActionsTask]
ReadPrec DescribeAuditMitigationActionsTask
Int -> ReadS DescribeAuditMitigationActionsTask
ReadS [DescribeAuditMitigationActionsTask]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeAuditMitigationActionsTask]
$creadListPrec :: ReadPrec [DescribeAuditMitigationActionsTask]
readPrec :: ReadPrec DescribeAuditMitigationActionsTask
$creadPrec :: ReadPrec DescribeAuditMitigationActionsTask
readList :: ReadS [DescribeAuditMitigationActionsTask]
$creadList :: ReadS [DescribeAuditMitigationActionsTask]
readsPrec :: Int -> ReadS DescribeAuditMitigationActionsTask
$creadsPrec :: Int -> ReadS DescribeAuditMitigationActionsTask
Prelude.Read, Int -> DescribeAuditMitigationActionsTask -> ShowS
[DescribeAuditMitigationActionsTask] -> ShowS
DescribeAuditMitigationActionsTask -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeAuditMitigationActionsTask] -> ShowS
$cshowList :: [DescribeAuditMitigationActionsTask] -> ShowS
show :: DescribeAuditMitigationActionsTask -> String
$cshow :: DescribeAuditMitigationActionsTask -> String
showsPrec :: Int -> DescribeAuditMitigationActionsTask -> ShowS
$cshowsPrec :: Int -> DescribeAuditMitigationActionsTask -> ShowS
Prelude.Show, forall x.
Rep DescribeAuditMitigationActionsTask x
-> DescribeAuditMitigationActionsTask
forall x.
DescribeAuditMitigationActionsTask
-> Rep DescribeAuditMitigationActionsTask x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeAuditMitigationActionsTask x
-> DescribeAuditMitigationActionsTask
$cfrom :: forall x.
DescribeAuditMitigationActionsTask
-> Rep DescribeAuditMitigationActionsTask x
Prelude.Generic)

-- |
-- Create a value of 'DescribeAuditMitigationActionsTask' 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:
--
-- 'taskId', 'describeAuditMitigationActionsTask_taskId' - The unique identifier for the audit mitigation task.
newDescribeAuditMitigationActionsTask ::
  -- | 'taskId'
  Prelude.Text ->
  DescribeAuditMitigationActionsTask
newDescribeAuditMitigationActionsTask :: Text -> DescribeAuditMitigationActionsTask
newDescribeAuditMitigationActionsTask Text
pTaskId_ =
  DescribeAuditMitigationActionsTask'
    { $sel:taskId:DescribeAuditMitigationActionsTask' :: Text
taskId =
        Text
pTaskId_
    }

-- | The unique identifier for the audit mitigation task.
describeAuditMitigationActionsTask_taskId :: Lens.Lens' DescribeAuditMitigationActionsTask Prelude.Text
describeAuditMitigationActionsTask_taskId :: Lens' DescribeAuditMitigationActionsTask Text
describeAuditMitigationActionsTask_taskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTask' {Text
taskId :: Text
$sel:taskId:DescribeAuditMitigationActionsTask' :: DescribeAuditMitigationActionsTask -> Text
taskId} -> Text
taskId) (\s :: DescribeAuditMitigationActionsTask
s@DescribeAuditMitigationActionsTask' {} Text
a -> DescribeAuditMitigationActionsTask
s {$sel:taskId:DescribeAuditMitigationActionsTask' :: Text
taskId = Text
a} :: DescribeAuditMitigationActionsTask)

instance
  Core.AWSRequest
    DescribeAuditMitigationActionsTask
  where
  type
    AWSResponse DescribeAuditMitigationActionsTask =
      DescribeAuditMitigationActionsTaskResponse
  request :: (Service -> Service)
-> DescribeAuditMitigationActionsTask
-> Request DescribeAuditMitigationActionsTask
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 DescribeAuditMitigationActionsTask
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse DescribeAuditMitigationActionsTask)))
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 [MitigationAction]
-> Maybe (HashMap Text (NonEmpty Text))
-> Maybe POSIX
-> Maybe POSIX
-> Maybe AuditMitigationActionsTaskTarget
-> Maybe (HashMap Text TaskStatisticsForAuditCheck)
-> Maybe AuditMitigationActionsTaskStatus
-> Int
-> DescribeAuditMitigationActionsTaskResponse
DescribeAuditMitigationActionsTaskResponse'
            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
"actionsDefinition"
                            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
"auditCheckToActionsMapping"
                            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
"endTime")
            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
"startTime")
            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
"target")
            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
"taskStatistics" 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
"taskStatus")
            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
    DescribeAuditMitigationActionsTask
  where
  hashWithSalt :: Int -> DescribeAuditMitigationActionsTask -> Int
hashWithSalt
    Int
_salt
    DescribeAuditMitigationActionsTask' {Text
taskId :: Text
$sel:taskId:DescribeAuditMitigationActionsTask' :: DescribeAuditMitigationActionsTask -> Text
..} =
      Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
taskId

instance
  Prelude.NFData
    DescribeAuditMitigationActionsTask
  where
  rnf :: DescribeAuditMitigationActionsTask -> ()
rnf DescribeAuditMitigationActionsTask' {Text
taskId :: Text
$sel:taskId:DescribeAuditMitigationActionsTask' :: DescribeAuditMitigationActionsTask -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
taskId

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

instance
  Data.ToPath
    DescribeAuditMitigationActionsTask
  where
  toPath :: DescribeAuditMitigationActionsTask -> ByteString
toPath DescribeAuditMitigationActionsTask' {Text
taskId :: Text
$sel:taskId:DescribeAuditMitigationActionsTask' :: DescribeAuditMitigationActionsTask -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/audit/mitigationactions/tasks/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
taskId]

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

-- | /See:/ 'newDescribeAuditMitigationActionsTaskResponse' smart constructor.
data DescribeAuditMitigationActionsTaskResponse = DescribeAuditMitigationActionsTaskResponse'
  { -- | Specifies the mitigation actions and their parameters that are applied
    -- as part of this task.
    DescribeAuditMitigationActionsTaskResponse
-> Maybe [MitigationAction]
actionsDefinition :: Prelude.Maybe [MitigationAction],
    -- | Specifies the mitigation actions that should be applied to specific
    -- audit checks.
    DescribeAuditMitigationActionsTaskResponse
-> Maybe (HashMap Text (NonEmpty Text))
auditCheckToActionsMapping :: Prelude.Maybe (Prelude.HashMap Prelude.Text (Prelude.NonEmpty Prelude.Text)),
    -- | The date and time when the task was completed or canceled.
    DescribeAuditMitigationActionsTaskResponse -> Maybe POSIX
endTime :: Prelude.Maybe Data.POSIX,
    -- | The date and time when the task was started.
    DescribeAuditMitigationActionsTaskResponse -> Maybe POSIX
startTime :: Prelude.Maybe Data.POSIX,
    -- | Identifies the findings to which the mitigation actions are applied.
    -- This can be by audit checks, by audit task, or a set of findings.
    DescribeAuditMitigationActionsTaskResponse
-> Maybe AuditMitigationActionsTaskTarget
target :: Prelude.Maybe AuditMitigationActionsTaskTarget,
    -- | Aggregate counts of the results when the mitigation tasks were applied
    -- to the findings for this audit mitigation actions task.
    DescribeAuditMitigationActionsTaskResponse
-> Maybe (HashMap Text TaskStatisticsForAuditCheck)
taskStatistics :: Prelude.Maybe (Prelude.HashMap Prelude.Text TaskStatisticsForAuditCheck),
    -- | The current status of the task.
    DescribeAuditMitigationActionsTaskResponse
-> Maybe AuditMitigationActionsTaskStatus
taskStatus :: Prelude.Maybe AuditMitigationActionsTaskStatus,
    -- | The response's http status code.
    DescribeAuditMitigationActionsTaskResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeAuditMitigationActionsTaskResponse
-> DescribeAuditMitigationActionsTaskResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeAuditMitigationActionsTaskResponse
-> DescribeAuditMitigationActionsTaskResponse -> Bool
$c/= :: DescribeAuditMitigationActionsTaskResponse
-> DescribeAuditMitigationActionsTaskResponse -> Bool
== :: DescribeAuditMitigationActionsTaskResponse
-> DescribeAuditMitigationActionsTaskResponse -> Bool
$c== :: DescribeAuditMitigationActionsTaskResponse
-> DescribeAuditMitigationActionsTaskResponse -> Bool
Prelude.Eq, ReadPrec [DescribeAuditMitigationActionsTaskResponse]
ReadPrec DescribeAuditMitigationActionsTaskResponse
Int -> ReadS DescribeAuditMitigationActionsTaskResponse
ReadS [DescribeAuditMitigationActionsTaskResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeAuditMitigationActionsTaskResponse]
$creadListPrec :: ReadPrec [DescribeAuditMitigationActionsTaskResponse]
readPrec :: ReadPrec DescribeAuditMitigationActionsTaskResponse
$creadPrec :: ReadPrec DescribeAuditMitigationActionsTaskResponse
readList :: ReadS [DescribeAuditMitigationActionsTaskResponse]
$creadList :: ReadS [DescribeAuditMitigationActionsTaskResponse]
readsPrec :: Int -> ReadS DescribeAuditMitigationActionsTaskResponse
$creadsPrec :: Int -> ReadS DescribeAuditMitigationActionsTaskResponse
Prelude.Read, Int -> DescribeAuditMitigationActionsTaskResponse -> ShowS
[DescribeAuditMitigationActionsTaskResponse] -> ShowS
DescribeAuditMitigationActionsTaskResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeAuditMitigationActionsTaskResponse] -> ShowS
$cshowList :: [DescribeAuditMitigationActionsTaskResponse] -> ShowS
show :: DescribeAuditMitigationActionsTaskResponse -> String
$cshow :: DescribeAuditMitigationActionsTaskResponse -> String
showsPrec :: Int -> DescribeAuditMitigationActionsTaskResponse -> ShowS
$cshowsPrec :: Int -> DescribeAuditMitigationActionsTaskResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeAuditMitigationActionsTaskResponse x
-> DescribeAuditMitigationActionsTaskResponse
forall x.
DescribeAuditMitigationActionsTaskResponse
-> Rep DescribeAuditMitigationActionsTaskResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeAuditMitigationActionsTaskResponse x
-> DescribeAuditMitigationActionsTaskResponse
$cfrom :: forall x.
DescribeAuditMitigationActionsTaskResponse
-> Rep DescribeAuditMitigationActionsTaskResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeAuditMitigationActionsTaskResponse' 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:
--
-- 'actionsDefinition', 'describeAuditMitigationActionsTaskResponse_actionsDefinition' - Specifies the mitigation actions and their parameters that are applied
-- as part of this task.
--
-- 'auditCheckToActionsMapping', 'describeAuditMitigationActionsTaskResponse_auditCheckToActionsMapping' - Specifies the mitigation actions that should be applied to specific
-- audit checks.
--
-- 'endTime', 'describeAuditMitigationActionsTaskResponse_endTime' - The date and time when the task was completed or canceled.
--
-- 'startTime', 'describeAuditMitigationActionsTaskResponse_startTime' - The date and time when the task was started.
--
-- 'target', 'describeAuditMitigationActionsTaskResponse_target' - Identifies the findings to which the mitigation actions are applied.
-- This can be by audit checks, by audit task, or a set of findings.
--
-- 'taskStatistics', 'describeAuditMitigationActionsTaskResponse_taskStatistics' - Aggregate counts of the results when the mitigation tasks were applied
-- to the findings for this audit mitigation actions task.
--
-- 'taskStatus', 'describeAuditMitigationActionsTaskResponse_taskStatus' - The current status of the task.
--
-- 'httpStatus', 'describeAuditMitigationActionsTaskResponse_httpStatus' - The response's http status code.
newDescribeAuditMitigationActionsTaskResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeAuditMitigationActionsTaskResponse
newDescribeAuditMitigationActionsTaskResponse :: Int -> DescribeAuditMitigationActionsTaskResponse
newDescribeAuditMitigationActionsTaskResponse
  Int
pHttpStatus_ =
    DescribeAuditMitigationActionsTaskResponse'
      { $sel:actionsDefinition:DescribeAuditMitigationActionsTaskResponse' :: Maybe [MitigationAction]
actionsDefinition =
          forall a. Maybe a
Prelude.Nothing,
        $sel:auditCheckToActionsMapping:DescribeAuditMitigationActionsTaskResponse' :: Maybe (HashMap Text (NonEmpty Text))
auditCheckToActionsMapping =
          forall a. Maybe a
Prelude.Nothing,
        $sel:endTime:DescribeAuditMitigationActionsTaskResponse' :: Maybe POSIX
endTime = forall a. Maybe a
Prelude.Nothing,
        $sel:startTime:DescribeAuditMitigationActionsTaskResponse' :: Maybe POSIX
startTime = forall a. Maybe a
Prelude.Nothing,
        $sel:target:DescribeAuditMitigationActionsTaskResponse' :: Maybe AuditMitigationActionsTaskTarget
target = forall a. Maybe a
Prelude.Nothing,
        $sel:taskStatistics:DescribeAuditMitigationActionsTaskResponse' :: Maybe (HashMap Text TaskStatisticsForAuditCheck)
taskStatistics =
          forall a. Maybe a
Prelude.Nothing,
        $sel:taskStatus:DescribeAuditMitigationActionsTaskResponse' :: Maybe AuditMitigationActionsTaskStatus
taskStatus = forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:DescribeAuditMitigationActionsTaskResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | Specifies the mitigation actions and their parameters that are applied
-- as part of this task.
describeAuditMitigationActionsTaskResponse_actionsDefinition :: Lens.Lens' DescribeAuditMitigationActionsTaskResponse (Prelude.Maybe [MitigationAction])
describeAuditMitigationActionsTaskResponse_actionsDefinition :: Lens'
  DescribeAuditMitigationActionsTaskResponse
  (Maybe [MitigationAction])
describeAuditMitigationActionsTaskResponse_actionsDefinition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTaskResponse' {Maybe [MitigationAction]
actionsDefinition :: Maybe [MitigationAction]
$sel:actionsDefinition:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe [MitigationAction]
actionsDefinition} -> Maybe [MitigationAction]
actionsDefinition) (\s :: DescribeAuditMitigationActionsTaskResponse
s@DescribeAuditMitigationActionsTaskResponse' {} Maybe [MitigationAction]
a -> DescribeAuditMitigationActionsTaskResponse
s {$sel:actionsDefinition:DescribeAuditMitigationActionsTaskResponse' :: Maybe [MitigationAction]
actionsDefinition = Maybe [MitigationAction]
a} :: DescribeAuditMitigationActionsTaskResponse) 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

-- | Specifies the mitigation actions that should be applied to specific
-- audit checks.
describeAuditMitigationActionsTaskResponse_auditCheckToActionsMapping :: Lens.Lens' DescribeAuditMitigationActionsTaskResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text (Prelude.NonEmpty Prelude.Text)))
describeAuditMitigationActionsTaskResponse_auditCheckToActionsMapping :: Lens'
  DescribeAuditMitigationActionsTaskResponse
  (Maybe (HashMap Text (NonEmpty Text)))
describeAuditMitigationActionsTaskResponse_auditCheckToActionsMapping = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTaskResponse' {Maybe (HashMap Text (NonEmpty Text))
auditCheckToActionsMapping :: Maybe (HashMap Text (NonEmpty Text))
$sel:auditCheckToActionsMapping:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe (HashMap Text (NonEmpty Text))
auditCheckToActionsMapping} -> Maybe (HashMap Text (NonEmpty Text))
auditCheckToActionsMapping) (\s :: DescribeAuditMitigationActionsTaskResponse
s@DescribeAuditMitigationActionsTaskResponse' {} Maybe (HashMap Text (NonEmpty Text))
a -> DescribeAuditMitigationActionsTaskResponse
s {$sel:auditCheckToActionsMapping:DescribeAuditMitigationActionsTaskResponse' :: Maybe (HashMap Text (NonEmpty Text))
auditCheckToActionsMapping = Maybe (HashMap Text (NonEmpty Text))
a} :: DescribeAuditMitigationActionsTaskResponse) 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 date and time when the task was completed or canceled.
describeAuditMitigationActionsTaskResponse_endTime :: Lens.Lens' DescribeAuditMitigationActionsTaskResponse (Prelude.Maybe Prelude.UTCTime)
describeAuditMitigationActionsTaskResponse_endTime :: Lens' DescribeAuditMitigationActionsTaskResponse (Maybe UTCTime)
describeAuditMitigationActionsTaskResponse_endTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTaskResponse' {Maybe POSIX
endTime :: Maybe POSIX
$sel:endTime:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse -> Maybe POSIX
endTime} -> Maybe POSIX
endTime) (\s :: DescribeAuditMitigationActionsTaskResponse
s@DescribeAuditMitigationActionsTaskResponse' {} Maybe POSIX
a -> DescribeAuditMitigationActionsTaskResponse
s {$sel:endTime:DescribeAuditMitigationActionsTaskResponse' :: Maybe POSIX
endTime = Maybe POSIX
a} :: DescribeAuditMitigationActionsTaskResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The date and time when the task was started.
describeAuditMitigationActionsTaskResponse_startTime :: Lens.Lens' DescribeAuditMitigationActionsTaskResponse (Prelude.Maybe Prelude.UTCTime)
describeAuditMitigationActionsTaskResponse_startTime :: Lens' DescribeAuditMitigationActionsTaskResponse (Maybe UTCTime)
describeAuditMitigationActionsTaskResponse_startTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTaskResponse' {Maybe POSIX
startTime :: Maybe POSIX
$sel:startTime:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse -> Maybe POSIX
startTime} -> Maybe POSIX
startTime) (\s :: DescribeAuditMitigationActionsTaskResponse
s@DescribeAuditMitigationActionsTaskResponse' {} Maybe POSIX
a -> DescribeAuditMitigationActionsTaskResponse
s {$sel:startTime:DescribeAuditMitigationActionsTaskResponse' :: Maybe POSIX
startTime = Maybe POSIX
a} :: DescribeAuditMitigationActionsTaskResponse) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Identifies the findings to which the mitigation actions are applied.
-- This can be by audit checks, by audit task, or a set of findings.
describeAuditMitigationActionsTaskResponse_target :: Lens.Lens' DescribeAuditMitigationActionsTaskResponse (Prelude.Maybe AuditMitigationActionsTaskTarget)
describeAuditMitigationActionsTaskResponse_target :: Lens'
  DescribeAuditMitigationActionsTaskResponse
  (Maybe AuditMitigationActionsTaskTarget)
describeAuditMitigationActionsTaskResponse_target = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTaskResponse' {Maybe AuditMitigationActionsTaskTarget
target :: Maybe AuditMitigationActionsTaskTarget
$sel:target:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe AuditMitigationActionsTaskTarget
target} -> Maybe AuditMitigationActionsTaskTarget
target) (\s :: DescribeAuditMitigationActionsTaskResponse
s@DescribeAuditMitigationActionsTaskResponse' {} Maybe AuditMitigationActionsTaskTarget
a -> DescribeAuditMitigationActionsTaskResponse
s {$sel:target:DescribeAuditMitigationActionsTaskResponse' :: Maybe AuditMitigationActionsTaskTarget
target = Maybe AuditMitigationActionsTaskTarget
a} :: DescribeAuditMitigationActionsTaskResponse)

-- | Aggregate counts of the results when the mitigation tasks were applied
-- to the findings for this audit mitigation actions task.
describeAuditMitigationActionsTaskResponse_taskStatistics :: Lens.Lens' DescribeAuditMitigationActionsTaskResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text TaskStatisticsForAuditCheck))
describeAuditMitigationActionsTaskResponse_taskStatistics :: Lens'
  DescribeAuditMitigationActionsTaskResponse
  (Maybe (HashMap Text TaskStatisticsForAuditCheck))
describeAuditMitigationActionsTaskResponse_taskStatistics = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTaskResponse' {Maybe (HashMap Text TaskStatisticsForAuditCheck)
taskStatistics :: Maybe (HashMap Text TaskStatisticsForAuditCheck)
$sel:taskStatistics:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe (HashMap Text TaskStatisticsForAuditCheck)
taskStatistics} -> Maybe (HashMap Text TaskStatisticsForAuditCheck)
taskStatistics) (\s :: DescribeAuditMitigationActionsTaskResponse
s@DescribeAuditMitigationActionsTaskResponse' {} Maybe (HashMap Text TaskStatisticsForAuditCheck)
a -> DescribeAuditMitigationActionsTaskResponse
s {$sel:taskStatistics:DescribeAuditMitigationActionsTaskResponse' :: Maybe (HashMap Text TaskStatisticsForAuditCheck)
taskStatistics = Maybe (HashMap Text TaskStatisticsForAuditCheck)
a} :: DescribeAuditMitigationActionsTaskResponse) 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 current status of the task.
describeAuditMitigationActionsTaskResponse_taskStatus :: Lens.Lens' DescribeAuditMitigationActionsTaskResponse (Prelude.Maybe AuditMitigationActionsTaskStatus)
describeAuditMitigationActionsTaskResponse_taskStatus :: Lens'
  DescribeAuditMitigationActionsTaskResponse
  (Maybe AuditMitigationActionsTaskStatus)
describeAuditMitigationActionsTaskResponse_taskStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeAuditMitigationActionsTaskResponse' {Maybe AuditMitigationActionsTaskStatus
taskStatus :: Maybe AuditMitigationActionsTaskStatus
$sel:taskStatus:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe AuditMitigationActionsTaskStatus
taskStatus} -> Maybe AuditMitigationActionsTaskStatus
taskStatus) (\s :: DescribeAuditMitigationActionsTaskResponse
s@DescribeAuditMitigationActionsTaskResponse' {} Maybe AuditMitigationActionsTaskStatus
a -> DescribeAuditMitigationActionsTaskResponse
s {$sel:taskStatus:DescribeAuditMitigationActionsTaskResponse' :: Maybe AuditMitigationActionsTaskStatus
taskStatus = Maybe AuditMitigationActionsTaskStatus
a} :: DescribeAuditMitigationActionsTaskResponse)

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

instance
  Prelude.NFData
    DescribeAuditMitigationActionsTaskResponse
  where
  rnf :: DescribeAuditMitigationActionsTaskResponse -> ()
rnf DescribeAuditMitigationActionsTaskResponse' {Int
Maybe [MitigationAction]
Maybe (HashMap Text (NonEmpty Text))
Maybe (HashMap Text TaskStatisticsForAuditCheck)
Maybe POSIX
Maybe AuditMitigationActionsTaskStatus
Maybe AuditMitigationActionsTaskTarget
httpStatus :: Int
taskStatus :: Maybe AuditMitigationActionsTaskStatus
taskStatistics :: Maybe (HashMap Text TaskStatisticsForAuditCheck)
target :: Maybe AuditMitigationActionsTaskTarget
startTime :: Maybe POSIX
endTime :: Maybe POSIX
auditCheckToActionsMapping :: Maybe (HashMap Text (NonEmpty Text))
actionsDefinition :: Maybe [MitigationAction]
$sel:httpStatus:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse -> Int
$sel:taskStatus:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe AuditMitigationActionsTaskStatus
$sel:taskStatistics:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe (HashMap Text TaskStatisticsForAuditCheck)
$sel:target:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe AuditMitigationActionsTaskTarget
$sel:startTime:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse -> Maybe POSIX
$sel:endTime:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse -> Maybe POSIX
$sel:auditCheckToActionsMapping:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe (HashMap Text (NonEmpty Text))
$sel:actionsDefinition:DescribeAuditMitigationActionsTaskResponse' :: DescribeAuditMitigationActionsTaskResponse
-> Maybe [MitigationAction]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [MitigationAction]
actionsDefinition
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text (NonEmpty Text))
auditCheckToActionsMapping
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
endTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
startTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AuditMitigationActionsTaskTarget
target
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text TaskStatisticsForAuditCheck)
taskStatistics
      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 Int
httpStatus