{-# 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.Inspector2.Types.CoveredResource
-- 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.Inspector2.Types.CoveredResource where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Inspector2.Types.CoverageResourceType
import Amazonka.Inspector2.Types.ResourceScanMetadata
import Amazonka.Inspector2.Types.ScanStatus
import Amazonka.Inspector2.Types.ScanType
import qualified Amazonka.Prelude as Prelude

-- | An object that contains details about a resource covered by Amazon
-- Inspector.
--
-- /See:/ 'newCoveredResource' smart constructor.
data CoveredResource = CoveredResource'
  { -- | An object that contains details about the metadata.
    CoveredResource -> Maybe ResourceScanMetadata
resourceMetadata :: Prelude.Maybe ResourceScanMetadata,
    -- | The status of the scan covering the resource.
    CoveredResource -> Maybe ScanStatus
scanStatus :: Prelude.Maybe ScanStatus,
    -- | The Amazon Web Services account ID of the covered resource.
    CoveredResource -> Text
accountId :: Prelude.Text,
    -- | The ID of the covered resource.
    CoveredResource -> Text
resourceId :: Prelude.Text,
    -- | The type of the covered resource.
    CoveredResource -> CoverageResourceType
resourceType :: CoverageResourceType,
    -- | The Amazon Inspector scan type covering the resource.
    CoveredResource -> ScanType
scanType :: ScanType
  }
  deriving (CoveredResource -> CoveredResource -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CoveredResource -> CoveredResource -> Bool
$c/= :: CoveredResource -> CoveredResource -> Bool
== :: CoveredResource -> CoveredResource -> Bool
$c== :: CoveredResource -> CoveredResource -> Bool
Prelude.Eq, ReadPrec [CoveredResource]
ReadPrec CoveredResource
Int -> ReadS CoveredResource
ReadS [CoveredResource]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CoveredResource]
$creadListPrec :: ReadPrec [CoveredResource]
readPrec :: ReadPrec CoveredResource
$creadPrec :: ReadPrec CoveredResource
readList :: ReadS [CoveredResource]
$creadList :: ReadS [CoveredResource]
readsPrec :: Int -> ReadS CoveredResource
$creadsPrec :: Int -> ReadS CoveredResource
Prelude.Read, Int -> CoveredResource -> ShowS
[CoveredResource] -> ShowS
CoveredResource -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CoveredResource] -> ShowS
$cshowList :: [CoveredResource] -> ShowS
show :: CoveredResource -> String
$cshow :: CoveredResource -> String
showsPrec :: Int -> CoveredResource -> ShowS
$cshowsPrec :: Int -> CoveredResource -> ShowS
Prelude.Show, forall x. Rep CoveredResource x -> CoveredResource
forall x. CoveredResource -> Rep CoveredResource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CoveredResource x -> CoveredResource
$cfrom :: forall x. CoveredResource -> Rep CoveredResource x
Prelude.Generic)

-- |
-- Create a value of 'CoveredResource' 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:
--
-- 'resourceMetadata', 'coveredResource_resourceMetadata' - An object that contains details about the metadata.
--
-- 'scanStatus', 'coveredResource_scanStatus' - The status of the scan covering the resource.
--
-- 'accountId', 'coveredResource_accountId' - The Amazon Web Services account ID of the covered resource.
--
-- 'resourceId', 'coveredResource_resourceId' - The ID of the covered resource.
--
-- 'resourceType', 'coveredResource_resourceType' - The type of the covered resource.
--
-- 'scanType', 'coveredResource_scanType' - The Amazon Inspector scan type covering the resource.
newCoveredResource ::
  -- | 'accountId'
  Prelude.Text ->
  -- | 'resourceId'
  Prelude.Text ->
  -- | 'resourceType'
  CoverageResourceType ->
  -- | 'scanType'
  ScanType ->
  CoveredResource
newCoveredResource :: Text -> Text -> CoverageResourceType -> ScanType -> CoveredResource
newCoveredResource
  Text
pAccountId_
  Text
pResourceId_
  CoverageResourceType
pResourceType_
  ScanType
pScanType_ =
    CoveredResource'
      { $sel:resourceMetadata:CoveredResource' :: Maybe ResourceScanMetadata
resourceMetadata =
          forall a. Maybe a
Prelude.Nothing,
        $sel:scanStatus:CoveredResource' :: Maybe ScanStatus
scanStatus = forall a. Maybe a
Prelude.Nothing,
        $sel:accountId:CoveredResource' :: Text
accountId = Text
pAccountId_,
        $sel:resourceId:CoveredResource' :: Text
resourceId = Text
pResourceId_,
        $sel:resourceType:CoveredResource' :: CoverageResourceType
resourceType = CoverageResourceType
pResourceType_,
        $sel:scanType:CoveredResource' :: ScanType
scanType = ScanType
pScanType_
      }

-- | An object that contains details about the metadata.
coveredResource_resourceMetadata :: Lens.Lens' CoveredResource (Prelude.Maybe ResourceScanMetadata)
coveredResource_resourceMetadata :: Lens' CoveredResource (Maybe ResourceScanMetadata)
coveredResource_resourceMetadata = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoveredResource' {Maybe ResourceScanMetadata
resourceMetadata :: Maybe ResourceScanMetadata
$sel:resourceMetadata:CoveredResource' :: CoveredResource -> Maybe ResourceScanMetadata
resourceMetadata} -> Maybe ResourceScanMetadata
resourceMetadata) (\s :: CoveredResource
s@CoveredResource' {} Maybe ResourceScanMetadata
a -> CoveredResource
s {$sel:resourceMetadata:CoveredResource' :: Maybe ResourceScanMetadata
resourceMetadata = Maybe ResourceScanMetadata
a} :: CoveredResource)

-- | The status of the scan covering the resource.
coveredResource_scanStatus :: Lens.Lens' CoveredResource (Prelude.Maybe ScanStatus)
coveredResource_scanStatus :: Lens' CoveredResource (Maybe ScanStatus)
coveredResource_scanStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoveredResource' {Maybe ScanStatus
scanStatus :: Maybe ScanStatus
$sel:scanStatus:CoveredResource' :: CoveredResource -> Maybe ScanStatus
scanStatus} -> Maybe ScanStatus
scanStatus) (\s :: CoveredResource
s@CoveredResource' {} Maybe ScanStatus
a -> CoveredResource
s {$sel:scanStatus:CoveredResource' :: Maybe ScanStatus
scanStatus = Maybe ScanStatus
a} :: CoveredResource)

-- | The Amazon Web Services account ID of the covered resource.
coveredResource_accountId :: Lens.Lens' CoveredResource Prelude.Text
coveredResource_accountId :: Lens' CoveredResource Text
coveredResource_accountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoveredResource' {Text
accountId :: Text
$sel:accountId:CoveredResource' :: CoveredResource -> Text
accountId} -> Text
accountId) (\s :: CoveredResource
s@CoveredResource' {} Text
a -> CoveredResource
s {$sel:accountId:CoveredResource' :: Text
accountId = Text
a} :: CoveredResource)

-- | The ID of the covered resource.
coveredResource_resourceId :: Lens.Lens' CoveredResource Prelude.Text
coveredResource_resourceId :: Lens' CoveredResource Text
coveredResource_resourceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoveredResource' {Text
resourceId :: Text
$sel:resourceId:CoveredResource' :: CoveredResource -> Text
resourceId} -> Text
resourceId) (\s :: CoveredResource
s@CoveredResource' {} Text
a -> CoveredResource
s {$sel:resourceId:CoveredResource' :: Text
resourceId = Text
a} :: CoveredResource)

-- | The type of the covered resource.
coveredResource_resourceType :: Lens.Lens' CoveredResource CoverageResourceType
coveredResource_resourceType :: Lens' CoveredResource CoverageResourceType
coveredResource_resourceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoveredResource' {CoverageResourceType
resourceType :: CoverageResourceType
$sel:resourceType:CoveredResource' :: CoveredResource -> CoverageResourceType
resourceType} -> CoverageResourceType
resourceType) (\s :: CoveredResource
s@CoveredResource' {} CoverageResourceType
a -> CoveredResource
s {$sel:resourceType:CoveredResource' :: CoverageResourceType
resourceType = CoverageResourceType
a} :: CoveredResource)

-- | The Amazon Inspector scan type covering the resource.
coveredResource_scanType :: Lens.Lens' CoveredResource ScanType
coveredResource_scanType :: Lens' CoveredResource ScanType
coveredResource_scanType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CoveredResource' {ScanType
scanType :: ScanType
$sel:scanType:CoveredResource' :: CoveredResource -> ScanType
scanType} -> ScanType
scanType) (\s :: CoveredResource
s@CoveredResource' {} ScanType
a -> CoveredResource
s {$sel:scanType:CoveredResource' :: ScanType
scanType = ScanType
a} :: CoveredResource)

instance Data.FromJSON CoveredResource where
  parseJSON :: Value -> Parser CoveredResource
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"CoveredResource"
      ( \Object
x ->
          Maybe ResourceScanMetadata
-> Maybe ScanStatus
-> Text
-> Text
-> CoverageResourceType
-> ScanType
-> CoveredResource
CoveredResource'
            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
"resourceMetadata")
            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
"scanStatus")
            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
"accountId")
            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
"resourceId")
            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
"resourceType")
            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
"scanType")
      )

instance Prelude.Hashable CoveredResource where
  hashWithSalt :: Int -> CoveredResource -> Int
hashWithSalt Int
_salt CoveredResource' {Maybe ResourceScanMetadata
Maybe ScanStatus
Text
CoverageResourceType
ScanType
scanType :: ScanType
resourceType :: CoverageResourceType
resourceId :: Text
accountId :: Text
scanStatus :: Maybe ScanStatus
resourceMetadata :: Maybe ResourceScanMetadata
$sel:scanType:CoveredResource' :: CoveredResource -> ScanType
$sel:resourceType:CoveredResource' :: CoveredResource -> CoverageResourceType
$sel:resourceId:CoveredResource' :: CoveredResource -> Text
$sel:accountId:CoveredResource' :: CoveredResource -> Text
$sel:scanStatus:CoveredResource' :: CoveredResource -> Maybe ScanStatus
$sel:resourceMetadata:CoveredResource' :: CoveredResource -> Maybe ResourceScanMetadata
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ResourceScanMetadata
resourceMetadata
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ScanStatus
scanStatus
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
accountId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
resourceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` CoverageResourceType
resourceType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ScanType
scanType

instance Prelude.NFData CoveredResource where
  rnf :: CoveredResource -> ()
rnf CoveredResource' {Maybe ResourceScanMetadata
Maybe ScanStatus
Text
CoverageResourceType
ScanType
scanType :: ScanType
resourceType :: CoverageResourceType
resourceId :: Text
accountId :: Text
scanStatus :: Maybe ScanStatus
resourceMetadata :: Maybe ResourceScanMetadata
$sel:scanType:CoveredResource' :: CoveredResource -> ScanType
$sel:resourceType:CoveredResource' :: CoveredResource -> CoverageResourceType
$sel:resourceId:CoveredResource' :: CoveredResource -> Text
$sel:accountId:CoveredResource' :: CoveredResource -> Text
$sel:scanStatus:CoveredResource' :: CoveredResource -> Maybe ScanStatus
$sel:resourceMetadata:CoveredResource' :: CoveredResource -> Maybe ResourceScanMetadata
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ResourceScanMetadata
resourceMetadata
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ScanStatus
scanStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
accountId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
resourceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf CoverageResourceType
resourceType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ScanType
scanType