{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.SSM.Types.InstancePatchState
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.SSM.Types.InstancePatchState where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.SSM.Types.PatchOperationType
import Amazonka.SSM.Types.RebootOption

-- | Defines the high-level patch compliance state for a managed node,
-- providing information about the number of installed, missing, not
-- applicable, and failed patches along with metadata about the operation
-- when this information was gathered for the managed node.
--
-- /See:/ 'newInstancePatchState' smart constructor.
data InstancePatchState = InstancePatchState'
  { -- | The number of patches per node that are specified as @Critical@ for
    -- compliance reporting in the patch baseline aren\'t installed. These
    -- patches might be missing, have failed installation, were rejected, or
    -- were installed but awaiting a required managed node reboot. The status
    -- of these managed nodes is @NON_COMPLIANT@.
    InstancePatchState -> Maybe Int
criticalNonCompliantCount :: Prelude.Maybe Prelude.Int,
    -- | The number of patches from the patch baseline that were attempted to be
    -- installed during the last patching operation, but failed to install.
    InstancePatchState -> Maybe Int
failedCount :: Prelude.Maybe Prelude.Int,
    -- | An https URL or an Amazon Simple Storage Service (Amazon S3) path-style
    -- URL to a list of patches to be installed. This patch installation list,
    -- which you maintain in an S3 bucket in YAML format and specify in the SSM
    -- document @AWS-RunPatchBaseline@, overrides the patches specified by the
    -- default patch baseline.
    --
    -- For more information about the @InstallOverrideList@ parameter, see
    -- <https://docs.aws.amazon.com/systems-manager/latest/userguide/patch-manager-about-aws-runpatchbaseline.html About the AWS-RunPatchBaseline>
    -- SSM document in the /Amazon Web Services Systems Manager User Guide/.
    InstancePatchState -> Maybe Text
installOverrideList :: Prelude.Maybe Prelude.Text,
    -- | The number of patches from the patch baseline that are installed on the
    -- managed node.
    InstancePatchState -> Maybe Int
installedCount :: Prelude.Maybe Prelude.Int,
    -- | The number of patches not specified in the patch baseline that are
    -- installed on the managed node.
    InstancePatchState -> Maybe Int
installedOtherCount :: Prelude.Maybe Prelude.Int,
    -- | The number of patches installed by Patch Manager since the last time the
    -- managed node was rebooted.
    InstancePatchState -> Maybe Int
installedPendingRebootCount :: Prelude.Maybe Prelude.Int,
    -- | The number of patches installed on a managed node that are specified in
    -- a @RejectedPatches@ list. Patches with a status of @InstalledRejected@
    -- were typically installed before they were added to a @RejectedPatches@
    -- list.
    --
    -- If @ALLOW_AS_DEPENDENCY@ is the specified option for
    -- @RejectedPatchesAction@, the value of @InstalledRejectedCount@ will
    -- always be @0@ (zero).
    InstancePatchState -> Maybe Int
installedRejectedCount :: Prelude.Maybe Prelude.Int,
    -- | The time of the last attempt to patch the managed node with @NoReboot@
    -- specified as the reboot option.
    InstancePatchState -> Maybe POSIX
lastNoRebootInstallOperationTime :: Prelude.Maybe Data.POSIX,
    -- | The number of patches from the patch baseline that are applicable for
    -- the managed node but aren\'t currently installed.
    InstancePatchState -> Maybe Int
missingCount :: Prelude.Maybe Prelude.Int,
    -- | The number of patches from the patch baseline that aren\'t applicable
    -- for the managed node and therefore aren\'t installed on the node. This
    -- number may be truncated if the list of patch names is very large. The
    -- number of patches beyond this limit are reported in
    -- @UnreportedNotApplicableCount@.
    InstancePatchState -> Maybe Int
notApplicableCount :: Prelude.Maybe Prelude.Int,
    -- | The number of patches per node that are specified as other than
    -- @Critical@ or @Security@ but aren\'t compliant with the patch baseline.
    -- The status of these managed nodes is @NON_COMPLIANT@.
    InstancePatchState -> Maybe Int
otherNonCompliantCount :: Prelude.Maybe Prelude.Int,
    -- | Placeholder information. This field will always be empty in the current
    -- release of the service.
    InstancePatchState -> Maybe (Sensitive Text)
ownerInformation :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | Indicates the reboot option specified in the patch baseline.
    --
    -- Reboot options apply to @Install@ operations only. Reboots aren\'t
    -- attempted for Patch Manager @Scan@ operations.
    --
    -- -   @RebootIfNeeded@: Patch Manager tries to reboot the managed node if
    --     it installed any patches, or if any patches are detected with a
    --     status of @InstalledPendingReboot@.
    --
    -- -   @NoReboot@: Patch Manager attempts to install missing packages
    --     without trying to reboot the system. Patches installed with this
    --     option are assigned a status of @InstalledPendingReboot@. These
    --     patches might not be in effect until a reboot is performed.
    InstancePatchState -> Maybe RebootOption
rebootOption :: Prelude.Maybe RebootOption,
    -- | The number of patches per node that are specified as @Security@ in a
    -- patch advisory aren\'t installed. These patches might be missing, have
    -- failed installation, were rejected, or were installed but awaiting a
    -- required managed node reboot. The status of these managed nodes is
    -- @NON_COMPLIANT@.
    InstancePatchState -> Maybe Int
securityNonCompliantCount :: Prelude.Maybe Prelude.Int,
    -- | The ID of the patch baseline snapshot used during the patching operation
    -- when this compliance data was collected.
    InstancePatchState -> Maybe Text
snapshotId :: Prelude.Maybe Prelude.Text,
    -- | The number of patches beyond the supported limit of @NotApplicableCount@
    -- that aren\'t reported by name to Inventory. Inventory is a capability of
    -- Amazon Web Services Systems Manager.
    InstancePatchState -> Maybe Int
unreportedNotApplicableCount :: Prelude.Maybe Prelude.Int,
    -- | The ID of the managed node the high-level patch compliance information
    -- was collected for.
    InstancePatchState -> Text
instanceId :: Prelude.Text,
    -- | The name of the patch group the managed node belongs to.
    InstancePatchState -> Text
patchGroup :: Prelude.Text,
    -- | The ID of the patch baseline used to patch the managed node.
    InstancePatchState -> Text
baselineId :: Prelude.Text,
    -- | The time the most recent patching operation was started on the managed
    -- node.
    InstancePatchState -> POSIX
operationStartTime :: Data.POSIX,
    -- | The time the most recent patching operation completed on the managed
    -- node.
    InstancePatchState -> POSIX
operationEndTime :: Data.POSIX,
    -- | The type of patching operation that was performed: or
    --
    -- -   @SCAN@ assesses the patch compliance state.
    --
    -- -   @INSTALL@ installs missing patches.
    InstancePatchState -> PatchOperationType
operation :: PatchOperationType
  }
  deriving (InstancePatchState -> InstancePatchState -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InstancePatchState -> InstancePatchState -> Bool
$c/= :: InstancePatchState -> InstancePatchState -> Bool
== :: InstancePatchState -> InstancePatchState -> Bool
$c== :: InstancePatchState -> InstancePatchState -> Bool
Prelude.Eq, Int -> InstancePatchState -> ShowS
[InstancePatchState] -> ShowS
InstancePatchState -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InstancePatchState] -> ShowS
$cshowList :: [InstancePatchState] -> ShowS
show :: InstancePatchState -> String
$cshow :: InstancePatchState -> String
showsPrec :: Int -> InstancePatchState -> ShowS
$cshowsPrec :: Int -> InstancePatchState -> ShowS
Prelude.Show, forall x. Rep InstancePatchState x -> InstancePatchState
forall x. InstancePatchState -> Rep InstancePatchState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InstancePatchState x -> InstancePatchState
$cfrom :: forall x. InstancePatchState -> Rep InstancePatchState x
Prelude.Generic)

-- |
-- Create a value of 'InstancePatchState' 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:
--
-- 'criticalNonCompliantCount', 'instancePatchState_criticalNonCompliantCount' - The number of patches per node that are specified as @Critical@ for
-- compliance reporting in the patch baseline aren\'t installed. These
-- patches might be missing, have failed installation, were rejected, or
-- were installed but awaiting a required managed node reboot. The status
-- of these managed nodes is @NON_COMPLIANT@.
--
-- 'failedCount', 'instancePatchState_failedCount' - The number of patches from the patch baseline that were attempted to be
-- installed during the last patching operation, but failed to install.
--
-- 'installOverrideList', 'instancePatchState_installOverrideList' - An https URL or an Amazon Simple Storage Service (Amazon S3) path-style
-- URL to a list of patches to be installed. This patch installation list,
-- which you maintain in an S3 bucket in YAML format and specify in the SSM
-- document @AWS-RunPatchBaseline@, overrides the patches specified by the
-- default patch baseline.
--
-- For more information about the @InstallOverrideList@ parameter, see
-- <https://docs.aws.amazon.com/systems-manager/latest/userguide/patch-manager-about-aws-runpatchbaseline.html About the AWS-RunPatchBaseline>
-- SSM document in the /Amazon Web Services Systems Manager User Guide/.
--
-- 'installedCount', 'instancePatchState_installedCount' - The number of patches from the patch baseline that are installed on the
-- managed node.
--
-- 'installedOtherCount', 'instancePatchState_installedOtherCount' - The number of patches not specified in the patch baseline that are
-- installed on the managed node.
--
-- 'installedPendingRebootCount', 'instancePatchState_installedPendingRebootCount' - The number of patches installed by Patch Manager since the last time the
-- managed node was rebooted.
--
-- 'installedRejectedCount', 'instancePatchState_installedRejectedCount' - The number of patches installed on a managed node that are specified in
-- a @RejectedPatches@ list. Patches with a status of @InstalledRejected@
-- were typically installed before they were added to a @RejectedPatches@
-- list.
--
-- If @ALLOW_AS_DEPENDENCY@ is the specified option for
-- @RejectedPatchesAction@, the value of @InstalledRejectedCount@ will
-- always be @0@ (zero).
--
-- 'lastNoRebootInstallOperationTime', 'instancePatchState_lastNoRebootInstallOperationTime' - The time of the last attempt to patch the managed node with @NoReboot@
-- specified as the reboot option.
--
-- 'missingCount', 'instancePatchState_missingCount' - The number of patches from the patch baseline that are applicable for
-- the managed node but aren\'t currently installed.
--
-- 'notApplicableCount', 'instancePatchState_notApplicableCount' - The number of patches from the patch baseline that aren\'t applicable
-- for the managed node and therefore aren\'t installed on the node. This
-- number may be truncated if the list of patch names is very large. The
-- number of patches beyond this limit are reported in
-- @UnreportedNotApplicableCount@.
--
-- 'otherNonCompliantCount', 'instancePatchState_otherNonCompliantCount' - The number of patches per node that are specified as other than
-- @Critical@ or @Security@ but aren\'t compliant with the patch baseline.
-- The status of these managed nodes is @NON_COMPLIANT@.
--
-- 'ownerInformation', 'instancePatchState_ownerInformation' - Placeholder information. This field will always be empty in the current
-- release of the service.
--
-- 'rebootOption', 'instancePatchState_rebootOption' - Indicates the reboot option specified in the patch baseline.
--
-- Reboot options apply to @Install@ operations only. Reboots aren\'t
-- attempted for Patch Manager @Scan@ operations.
--
-- -   @RebootIfNeeded@: Patch Manager tries to reboot the managed node if
--     it installed any patches, or if any patches are detected with a
--     status of @InstalledPendingReboot@.
--
-- -   @NoReboot@: Patch Manager attempts to install missing packages
--     without trying to reboot the system. Patches installed with this
--     option are assigned a status of @InstalledPendingReboot@. These
--     patches might not be in effect until a reboot is performed.
--
-- 'securityNonCompliantCount', 'instancePatchState_securityNonCompliantCount' - The number of patches per node that are specified as @Security@ in a
-- patch advisory aren\'t installed. These patches might be missing, have
-- failed installation, were rejected, or were installed but awaiting a
-- required managed node reboot. The status of these managed nodes is
-- @NON_COMPLIANT@.
--
-- 'snapshotId', 'instancePatchState_snapshotId' - The ID of the patch baseline snapshot used during the patching operation
-- when this compliance data was collected.
--
-- 'unreportedNotApplicableCount', 'instancePatchState_unreportedNotApplicableCount' - The number of patches beyond the supported limit of @NotApplicableCount@
-- that aren\'t reported by name to Inventory. Inventory is a capability of
-- Amazon Web Services Systems Manager.
--
-- 'instanceId', 'instancePatchState_instanceId' - The ID of the managed node the high-level patch compliance information
-- was collected for.
--
-- 'patchGroup', 'instancePatchState_patchGroup' - The name of the patch group the managed node belongs to.
--
-- 'baselineId', 'instancePatchState_baselineId' - The ID of the patch baseline used to patch the managed node.
--
-- 'operationStartTime', 'instancePatchState_operationStartTime' - The time the most recent patching operation was started on the managed
-- node.
--
-- 'operationEndTime', 'instancePatchState_operationEndTime' - The time the most recent patching operation completed on the managed
-- node.
--
-- 'operation', 'instancePatchState_operation' - The type of patching operation that was performed: or
--
-- -   @SCAN@ assesses the patch compliance state.
--
-- -   @INSTALL@ installs missing patches.
newInstancePatchState ::
  -- | 'instanceId'
  Prelude.Text ->
  -- | 'patchGroup'
  Prelude.Text ->
  -- | 'baselineId'
  Prelude.Text ->
  -- | 'operationStartTime'
  Prelude.UTCTime ->
  -- | 'operationEndTime'
  Prelude.UTCTime ->
  -- | 'operation'
  PatchOperationType ->
  InstancePatchState
newInstancePatchState :: Text
-> Text
-> Text
-> UTCTime
-> UTCTime
-> PatchOperationType
-> InstancePatchState
newInstancePatchState
  Text
pInstanceId_
  Text
pPatchGroup_
  Text
pBaselineId_
  UTCTime
pOperationStartTime_
  UTCTime
pOperationEndTime_
  PatchOperationType
pOperation_ =
    InstancePatchState'
      { $sel:criticalNonCompliantCount:InstancePatchState' :: Maybe Int
criticalNonCompliantCount =
          forall a. Maybe a
Prelude.Nothing,
        $sel:failedCount:InstancePatchState' :: Maybe Int
failedCount = forall a. Maybe a
Prelude.Nothing,
        $sel:installOverrideList:InstancePatchState' :: Maybe Text
installOverrideList = forall a. Maybe a
Prelude.Nothing,
        $sel:installedCount:InstancePatchState' :: Maybe Int
installedCount = forall a. Maybe a
Prelude.Nothing,
        $sel:installedOtherCount:InstancePatchState' :: Maybe Int
installedOtherCount = forall a. Maybe a
Prelude.Nothing,
        $sel:installedPendingRebootCount:InstancePatchState' :: Maybe Int
installedPendingRebootCount = forall a. Maybe a
Prelude.Nothing,
        $sel:installedRejectedCount:InstancePatchState' :: Maybe Int
installedRejectedCount = forall a. Maybe a
Prelude.Nothing,
        $sel:lastNoRebootInstallOperationTime:InstancePatchState' :: Maybe POSIX
lastNoRebootInstallOperationTime = forall a. Maybe a
Prelude.Nothing,
        $sel:missingCount:InstancePatchState' :: Maybe Int
missingCount = forall a. Maybe a
Prelude.Nothing,
        $sel:notApplicableCount:InstancePatchState' :: Maybe Int
notApplicableCount = forall a. Maybe a
Prelude.Nothing,
        $sel:otherNonCompliantCount:InstancePatchState' :: Maybe Int
otherNonCompliantCount = forall a. Maybe a
Prelude.Nothing,
        $sel:ownerInformation:InstancePatchState' :: Maybe (Sensitive Text)
ownerInformation = forall a. Maybe a
Prelude.Nothing,
        $sel:rebootOption:InstancePatchState' :: Maybe RebootOption
rebootOption = forall a. Maybe a
Prelude.Nothing,
        $sel:securityNonCompliantCount:InstancePatchState' :: Maybe Int
securityNonCompliantCount = forall a. Maybe a
Prelude.Nothing,
        $sel:snapshotId:InstancePatchState' :: Maybe Text
snapshotId = forall a. Maybe a
Prelude.Nothing,
        $sel:unreportedNotApplicableCount:InstancePatchState' :: Maybe Int
unreportedNotApplicableCount = forall a. Maybe a
Prelude.Nothing,
        $sel:instanceId:InstancePatchState' :: Text
instanceId = Text
pInstanceId_,
        $sel:patchGroup:InstancePatchState' :: Text
patchGroup = Text
pPatchGroup_,
        $sel:baselineId:InstancePatchState' :: Text
baselineId = Text
pBaselineId_,
        $sel:operationStartTime:InstancePatchState' :: POSIX
operationStartTime =
          forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pOperationStartTime_,
        $sel:operationEndTime:InstancePatchState' :: POSIX
operationEndTime =
          forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pOperationEndTime_,
        $sel:operation:InstancePatchState' :: PatchOperationType
operation = PatchOperationType
pOperation_
      }

-- | The number of patches per node that are specified as @Critical@ for
-- compliance reporting in the patch baseline aren\'t installed. These
-- patches might be missing, have failed installation, were rejected, or
-- were installed but awaiting a required managed node reboot. The status
-- of these managed nodes is @NON_COMPLIANT@.
instancePatchState_criticalNonCompliantCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_criticalNonCompliantCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_criticalNonCompliantCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
criticalNonCompliantCount :: Maybe Int
$sel:criticalNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
criticalNonCompliantCount} -> Maybe Int
criticalNonCompliantCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:criticalNonCompliantCount:InstancePatchState' :: Maybe Int
criticalNonCompliantCount = Maybe Int
a} :: InstancePatchState)

-- | The number of patches from the patch baseline that were attempted to be
-- installed during the last patching operation, but failed to install.
instancePatchState_failedCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_failedCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_failedCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
failedCount :: Maybe Int
$sel:failedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
failedCount} -> Maybe Int
failedCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:failedCount:InstancePatchState' :: Maybe Int
failedCount = Maybe Int
a} :: InstancePatchState)

-- | An https URL or an Amazon Simple Storage Service (Amazon S3) path-style
-- URL to a list of patches to be installed. This patch installation list,
-- which you maintain in an S3 bucket in YAML format and specify in the SSM
-- document @AWS-RunPatchBaseline@, overrides the patches specified by the
-- default patch baseline.
--
-- For more information about the @InstallOverrideList@ parameter, see
-- <https://docs.aws.amazon.com/systems-manager/latest/userguide/patch-manager-about-aws-runpatchbaseline.html About the AWS-RunPatchBaseline>
-- SSM document in the /Amazon Web Services Systems Manager User Guide/.
instancePatchState_installOverrideList :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Text)
instancePatchState_installOverrideList :: Lens' InstancePatchState (Maybe Text)
instancePatchState_installOverrideList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Text
installOverrideList :: Maybe Text
$sel:installOverrideList:InstancePatchState' :: InstancePatchState -> Maybe Text
installOverrideList} -> Maybe Text
installOverrideList) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Text
a -> InstancePatchState
s {$sel:installOverrideList:InstancePatchState' :: Maybe Text
installOverrideList = Maybe Text
a} :: InstancePatchState)

-- | The number of patches from the patch baseline that are installed on the
-- managed node.
instancePatchState_installedCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_installedCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_installedCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
installedCount :: Maybe Int
$sel:installedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
installedCount} -> Maybe Int
installedCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:installedCount:InstancePatchState' :: Maybe Int
installedCount = Maybe Int
a} :: InstancePatchState)

-- | The number of patches not specified in the patch baseline that are
-- installed on the managed node.
instancePatchState_installedOtherCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_installedOtherCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_installedOtherCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
installedOtherCount :: Maybe Int
$sel:installedOtherCount:InstancePatchState' :: InstancePatchState -> Maybe Int
installedOtherCount} -> Maybe Int
installedOtherCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:installedOtherCount:InstancePatchState' :: Maybe Int
installedOtherCount = Maybe Int
a} :: InstancePatchState)

-- | The number of patches installed by Patch Manager since the last time the
-- managed node was rebooted.
instancePatchState_installedPendingRebootCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_installedPendingRebootCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_installedPendingRebootCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
installedPendingRebootCount :: Maybe Int
$sel:installedPendingRebootCount:InstancePatchState' :: InstancePatchState -> Maybe Int
installedPendingRebootCount} -> Maybe Int
installedPendingRebootCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:installedPendingRebootCount:InstancePatchState' :: Maybe Int
installedPendingRebootCount = Maybe Int
a} :: InstancePatchState)

-- | The number of patches installed on a managed node that are specified in
-- a @RejectedPatches@ list. Patches with a status of @InstalledRejected@
-- were typically installed before they were added to a @RejectedPatches@
-- list.
--
-- If @ALLOW_AS_DEPENDENCY@ is the specified option for
-- @RejectedPatchesAction@, the value of @InstalledRejectedCount@ will
-- always be @0@ (zero).
instancePatchState_installedRejectedCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_installedRejectedCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_installedRejectedCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
installedRejectedCount :: Maybe Int
$sel:installedRejectedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
installedRejectedCount} -> Maybe Int
installedRejectedCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:installedRejectedCount:InstancePatchState' :: Maybe Int
installedRejectedCount = Maybe Int
a} :: InstancePatchState)

-- | The time of the last attempt to patch the managed node with @NoReboot@
-- specified as the reboot option.
instancePatchState_lastNoRebootInstallOperationTime :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.UTCTime)
instancePatchState_lastNoRebootInstallOperationTime :: Lens' InstancePatchState (Maybe UTCTime)
instancePatchState_lastNoRebootInstallOperationTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe POSIX
lastNoRebootInstallOperationTime :: Maybe POSIX
$sel:lastNoRebootInstallOperationTime:InstancePatchState' :: InstancePatchState -> Maybe POSIX
lastNoRebootInstallOperationTime} -> Maybe POSIX
lastNoRebootInstallOperationTime) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe POSIX
a -> InstancePatchState
s {$sel:lastNoRebootInstallOperationTime:InstancePatchState' :: Maybe POSIX
lastNoRebootInstallOperationTime = Maybe POSIX
a} :: InstancePatchState) 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 number of patches from the patch baseline that are applicable for
-- the managed node but aren\'t currently installed.
instancePatchState_missingCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_missingCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_missingCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
missingCount :: Maybe Int
$sel:missingCount:InstancePatchState' :: InstancePatchState -> Maybe Int
missingCount} -> Maybe Int
missingCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:missingCount:InstancePatchState' :: Maybe Int
missingCount = Maybe Int
a} :: InstancePatchState)

-- | The number of patches from the patch baseline that aren\'t applicable
-- for the managed node and therefore aren\'t installed on the node. This
-- number may be truncated if the list of patch names is very large. The
-- number of patches beyond this limit are reported in
-- @UnreportedNotApplicableCount@.
instancePatchState_notApplicableCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_notApplicableCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_notApplicableCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
notApplicableCount :: Maybe Int
$sel:notApplicableCount:InstancePatchState' :: InstancePatchState -> Maybe Int
notApplicableCount} -> Maybe Int
notApplicableCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:notApplicableCount:InstancePatchState' :: Maybe Int
notApplicableCount = Maybe Int
a} :: InstancePatchState)

-- | The number of patches per node that are specified as other than
-- @Critical@ or @Security@ but aren\'t compliant with the patch baseline.
-- The status of these managed nodes is @NON_COMPLIANT@.
instancePatchState_otherNonCompliantCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_otherNonCompliantCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_otherNonCompliantCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
otherNonCompliantCount :: Maybe Int
$sel:otherNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
otherNonCompliantCount} -> Maybe Int
otherNonCompliantCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:otherNonCompliantCount:InstancePatchState' :: Maybe Int
otherNonCompliantCount = Maybe Int
a} :: InstancePatchState)

-- | Placeholder information. This field will always be empty in the current
-- release of the service.
instancePatchState_ownerInformation :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Text)
instancePatchState_ownerInformation :: Lens' InstancePatchState (Maybe Text)
instancePatchState_ownerInformation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe (Sensitive Text)
ownerInformation :: Maybe (Sensitive Text)
$sel:ownerInformation:InstancePatchState' :: InstancePatchState -> Maybe (Sensitive Text)
ownerInformation} -> Maybe (Sensitive Text)
ownerInformation) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe (Sensitive Text)
a -> InstancePatchState
s {$sel:ownerInformation:InstancePatchState' :: Maybe (Sensitive Text)
ownerInformation = Maybe (Sensitive Text)
a} :: InstancePatchState) 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. Iso' (Sensitive a) a
Data._Sensitive

-- | Indicates the reboot option specified in the patch baseline.
--
-- Reboot options apply to @Install@ operations only. Reboots aren\'t
-- attempted for Patch Manager @Scan@ operations.
--
-- -   @RebootIfNeeded@: Patch Manager tries to reboot the managed node if
--     it installed any patches, or if any patches are detected with a
--     status of @InstalledPendingReboot@.
--
-- -   @NoReboot@: Patch Manager attempts to install missing packages
--     without trying to reboot the system. Patches installed with this
--     option are assigned a status of @InstalledPendingReboot@. These
--     patches might not be in effect until a reboot is performed.
instancePatchState_rebootOption :: Lens.Lens' InstancePatchState (Prelude.Maybe RebootOption)
instancePatchState_rebootOption :: Lens' InstancePatchState (Maybe RebootOption)
instancePatchState_rebootOption = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe RebootOption
rebootOption :: Maybe RebootOption
$sel:rebootOption:InstancePatchState' :: InstancePatchState -> Maybe RebootOption
rebootOption} -> Maybe RebootOption
rebootOption) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe RebootOption
a -> InstancePatchState
s {$sel:rebootOption:InstancePatchState' :: Maybe RebootOption
rebootOption = Maybe RebootOption
a} :: InstancePatchState)

-- | The number of patches per node that are specified as @Security@ in a
-- patch advisory aren\'t installed. These patches might be missing, have
-- failed installation, were rejected, or were installed but awaiting a
-- required managed node reboot. The status of these managed nodes is
-- @NON_COMPLIANT@.
instancePatchState_securityNonCompliantCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_securityNonCompliantCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_securityNonCompliantCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
securityNonCompliantCount :: Maybe Int
$sel:securityNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
securityNonCompliantCount} -> Maybe Int
securityNonCompliantCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:securityNonCompliantCount:InstancePatchState' :: Maybe Int
securityNonCompliantCount = Maybe Int
a} :: InstancePatchState)

-- | The ID of the patch baseline snapshot used during the patching operation
-- when this compliance data was collected.
instancePatchState_snapshotId :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Text)
instancePatchState_snapshotId :: Lens' InstancePatchState (Maybe Text)
instancePatchState_snapshotId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Text
snapshotId :: Maybe Text
$sel:snapshotId:InstancePatchState' :: InstancePatchState -> Maybe Text
snapshotId} -> Maybe Text
snapshotId) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Text
a -> InstancePatchState
s {$sel:snapshotId:InstancePatchState' :: Maybe Text
snapshotId = Maybe Text
a} :: InstancePatchState)

-- | The number of patches beyond the supported limit of @NotApplicableCount@
-- that aren\'t reported by name to Inventory. Inventory is a capability of
-- Amazon Web Services Systems Manager.
instancePatchState_unreportedNotApplicableCount :: Lens.Lens' InstancePatchState (Prelude.Maybe Prelude.Int)
instancePatchState_unreportedNotApplicableCount :: Lens' InstancePatchState (Maybe Int)
instancePatchState_unreportedNotApplicableCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Maybe Int
unreportedNotApplicableCount :: Maybe Int
$sel:unreportedNotApplicableCount:InstancePatchState' :: InstancePatchState -> Maybe Int
unreportedNotApplicableCount} -> Maybe Int
unreportedNotApplicableCount) (\s :: InstancePatchState
s@InstancePatchState' {} Maybe Int
a -> InstancePatchState
s {$sel:unreportedNotApplicableCount:InstancePatchState' :: Maybe Int
unreportedNotApplicableCount = Maybe Int
a} :: InstancePatchState)

-- | The ID of the managed node the high-level patch compliance information
-- was collected for.
instancePatchState_instanceId :: Lens.Lens' InstancePatchState Prelude.Text
instancePatchState_instanceId :: Lens' InstancePatchState Text
instancePatchState_instanceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Text
instanceId :: Text
$sel:instanceId:InstancePatchState' :: InstancePatchState -> Text
instanceId} -> Text
instanceId) (\s :: InstancePatchState
s@InstancePatchState' {} Text
a -> InstancePatchState
s {$sel:instanceId:InstancePatchState' :: Text
instanceId = Text
a} :: InstancePatchState)

-- | The name of the patch group the managed node belongs to.
instancePatchState_patchGroup :: Lens.Lens' InstancePatchState Prelude.Text
instancePatchState_patchGroup :: Lens' InstancePatchState Text
instancePatchState_patchGroup = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Text
patchGroup :: Text
$sel:patchGroup:InstancePatchState' :: InstancePatchState -> Text
patchGroup} -> Text
patchGroup) (\s :: InstancePatchState
s@InstancePatchState' {} Text
a -> InstancePatchState
s {$sel:patchGroup:InstancePatchState' :: Text
patchGroup = Text
a} :: InstancePatchState)

-- | The ID of the patch baseline used to patch the managed node.
instancePatchState_baselineId :: Lens.Lens' InstancePatchState Prelude.Text
instancePatchState_baselineId :: Lens' InstancePatchState Text
instancePatchState_baselineId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {Text
baselineId :: Text
$sel:baselineId:InstancePatchState' :: InstancePatchState -> Text
baselineId} -> Text
baselineId) (\s :: InstancePatchState
s@InstancePatchState' {} Text
a -> InstancePatchState
s {$sel:baselineId:InstancePatchState' :: Text
baselineId = Text
a} :: InstancePatchState)

-- | The time the most recent patching operation was started on the managed
-- node.
instancePatchState_operationStartTime :: Lens.Lens' InstancePatchState Prelude.UTCTime
instancePatchState_operationStartTime :: Lens' InstancePatchState UTCTime
instancePatchState_operationStartTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {POSIX
operationStartTime :: POSIX
$sel:operationStartTime:InstancePatchState' :: InstancePatchState -> POSIX
operationStartTime} -> POSIX
operationStartTime) (\s :: InstancePatchState
s@InstancePatchState' {} POSIX
a -> InstancePatchState
s {$sel:operationStartTime:InstancePatchState' :: POSIX
operationStartTime = POSIX
a} :: InstancePatchState) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The time the most recent patching operation completed on the managed
-- node.
instancePatchState_operationEndTime :: Lens.Lens' InstancePatchState Prelude.UTCTime
instancePatchState_operationEndTime :: Lens' InstancePatchState UTCTime
instancePatchState_operationEndTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {POSIX
operationEndTime :: POSIX
$sel:operationEndTime:InstancePatchState' :: InstancePatchState -> POSIX
operationEndTime} -> POSIX
operationEndTime) (\s :: InstancePatchState
s@InstancePatchState' {} POSIX
a -> InstancePatchState
s {$sel:operationEndTime:InstancePatchState' :: POSIX
operationEndTime = POSIX
a} :: InstancePatchState) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The type of patching operation that was performed: or
--
-- -   @SCAN@ assesses the patch compliance state.
--
-- -   @INSTALL@ installs missing patches.
instancePatchState_operation :: Lens.Lens' InstancePatchState PatchOperationType
instancePatchState_operation :: Lens' InstancePatchState PatchOperationType
instancePatchState_operation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\InstancePatchState' {PatchOperationType
operation :: PatchOperationType
$sel:operation:InstancePatchState' :: InstancePatchState -> PatchOperationType
operation} -> PatchOperationType
operation) (\s :: InstancePatchState
s@InstancePatchState' {} PatchOperationType
a -> InstancePatchState
s {$sel:operation:InstancePatchState' :: PatchOperationType
operation = PatchOperationType
a} :: InstancePatchState)

instance Data.FromJSON InstancePatchState where
  parseJSON :: Value -> Parser InstancePatchState
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"InstancePatchState"
      ( \Object
x ->
          Maybe Int
-> Maybe Int
-> Maybe Text
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe POSIX
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe (Sensitive Text)
-> Maybe RebootOption
-> Maybe Int
-> Maybe Text
-> Maybe Int
-> Text
-> Text
-> Text
-> POSIX
-> POSIX
-> PatchOperationType
-> InstancePatchState
InstancePatchState'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CriticalNonCompliantCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"FailedCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"InstallOverrideList")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"InstalledCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"InstalledOtherCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"InstalledPendingRebootCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"InstalledRejectedCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LastNoRebootInstallOperationTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"MissingCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"NotApplicableCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"OtherNonCompliantCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"OwnerInformation")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"RebootOption")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"SecurityNonCompliantCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"SnapshotId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"UnreportedNotApplicableCount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"InstanceId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"PatchGroup")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"BaselineId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"OperationStartTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"OperationEndTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Operation")
      )

instance Prelude.Hashable InstancePatchState where
  hashWithSalt :: Int -> InstancePatchState -> Int
hashWithSalt Int
_salt InstancePatchState' {Maybe Int
Maybe Text
Maybe (Sensitive Text)
Maybe POSIX
Maybe RebootOption
Text
POSIX
PatchOperationType
operation :: PatchOperationType
operationEndTime :: POSIX
operationStartTime :: POSIX
baselineId :: Text
patchGroup :: Text
instanceId :: Text
unreportedNotApplicableCount :: Maybe Int
snapshotId :: Maybe Text
securityNonCompliantCount :: Maybe Int
rebootOption :: Maybe RebootOption
ownerInformation :: Maybe (Sensitive Text)
otherNonCompliantCount :: Maybe Int
notApplicableCount :: Maybe Int
missingCount :: Maybe Int
lastNoRebootInstallOperationTime :: Maybe POSIX
installedRejectedCount :: Maybe Int
installedPendingRebootCount :: Maybe Int
installedOtherCount :: Maybe Int
installedCount :: Maybe Int
installOverrideList :: Maybe Text
failedCount :: Maybe Int
criticalNonCompliantCount :: Maybe Int
$sel:operation:InstancePatchState' :: InstancePatchState -> PatchOperationType
$sel:operationEndTime:InstancePatchState' :: InstancePatchState -> POSIX
$sel:operationStartTime:InstancePatchState' :: InstancePatchState -> POSIX
$sel:baselineId:InstancePatchState' :: InstancePatchState -> Text
$sel:patchGroup:InstancePatchState' :: InstancePatchState -> Text
$sel:instanceId:InstancePatchState' :: InstancePatchState -> Text
$sel:unreportedNotApplicableCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:snapshotId:InstancePatchState' :: InstancePatchState -> Maybe Text
$sel:securityNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:rebootOption:InstancePatchState' :: InstancePatchState -> Maybe RebootOption
$sel:ownerInformation:InstancePatchState' :: InstancePatchState -> Maybe (Sensitive Text)
$sel:otherNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:notApplicableCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:missingCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:lastNoRebootInstallOperationTime:InstancePatchState' :: InstancePatchState -> Maybe POSIX
$sel:installedRejectedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installedPendingRebootCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installedOtherCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installOverrideList:InstancePatchState' :: InstancePatchState -> Maybe Text
$sel:failedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:criticalNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
criticalNonCompliantCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
failedCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
installOverrideList
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
installedCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
installedOtherCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
installedPendingRebootCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
installedRejectedCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastNoRebootInstallOperationTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
missingCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
notApplicableCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
otherNonCompliantCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive Text)
ownerInformation
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RebootOption
rebootOption
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
securityNonCompliantCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
snapshotId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
unreportedNotApplicableCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
instanceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
patchGroup
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
baselineId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
operationStartTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
operationEndTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` PatchOperationType
operation

instance Prelude.NFData InstancePatchState where
  rnf :: InstancePatchState -> ()
rnf InstancePatchState' {Maybe Int
Maybe Text
Maybe (Sensitive Text)
Maybe POSIX
Maybe RebootOption
Text
POSIX
PatchOperationType
operation :: PatchOperationType
operationEndTime :: POSIX
operationStartTime :: POSIX
baselineId :: Text
patchGroup :: Text
instanceId :: Text
unreportedNotApplicableCount :: Maybe Int
snapshotId :: Maybe Text
securityNonCompliantCount :: Maybe Int
rebootOption :: Maybe RebootOption
ownerInformation :: Maybe (Sensitive Text)
otherNonCompliantCount :: Maybe Int
notApplicableCount :: Maybe Int
missingCount :: Maybe Int
lastNoRebootInstallOperationTime :: Maybe POSIX
installedRejectedCount :: Maybe Int
installedPendingRebootCount :: Maybe Int
installedOtherCount :: Maybe Int
installedCount :: Maybe Int
installOverrideList :: Maybe Text
failedCount :: Maybe Int
criticalNonCompliantCount :: Maybe Int
$sel:operation:InstancePatchState' :: InstancePatchState -> PatchOperationType
$sel:operationEndTime:InstancePatchState' :: InstancePatchState -> POSIX
$sel:operationStartTime:InstancePatchState' :: InstancePatchState -> POSIX
$sel:baselineId:InstancePatchState' :: InstancePatchState -> Text
$sel:patchGroup:InstancePatchState' :: InstancePatchState -> Text
$sel:instanceId:InstancePatchState' :: InstancePatchState -> Text
$sel:unreportedNotApplicableCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:snapshotId:InstancePatchState' :: InstancePatchState -> Maybe Text
$sel:securityNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:rebootOption:InstancePatchState' :: InstancePatchState -> Maybe RebootOption
$sel:ownerInformation:InstancePatchState' :: InstancePatchState -> Maybe (Sensitive Text)
$sel:otherNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:notApplicableCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:missingCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:lastNoRebootInstallOperationTime:InstancePatchState' :: InstancePatchState -> Maybe POSIX
$sel:installedRejectedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installedPendingRebootCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installedOtherCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:installOverrideList:InstancePatchState' :: InstancePatchState -> Maybe Text
$sel:failedCount:InstancePatchState' :: InstancePatchState -> Maybe Int
$sel:criticalNonCompliantCount:InstancePatchState' :: InstancePatchState -> Maybe Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
criticalNonCompliantCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
failedCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
installOverrideList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
installedCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
installedOtherCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
installedPendingRebootCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
installedRejectedCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastNoRebootInstallOperationTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
missingCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
notApplicableCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
otherNonCompliantCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
ownerInformation
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RebootOption
rebootOption
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
securityNonCompliantCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
snapshotId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe Int
unreportedNotApplicableCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
instanceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
patchGroup
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
baselineId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
operationStartTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
operationEndTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf PatchOperationType
operation