{-# 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.ECR.StartImageScan
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts an image vulnerability scan. An image scan can only be started
-- once per 24 hours on an individual image. This limit includes if an
-- image was scanned on initial push. For more information, see
-- <https://docs.aws.amazon.com/AmazonECR/latest/userguide/image-scanning.html Image scanning>
-- in the /Amazon Elastic Container Registry User Guide/.
module Amazonka.ECR.StartImageScan
  ( -- * Creating a Request
    StartImageScan (..),
    newStartImageScan,

    -- * Request Lenses
    startImageScan_registryId,
    startImageScan_repositoryName,
    startImageScan_imageId,

    -- * Destructuring the Response
    StartImageScanResponse (..),
    newStartImageScanResponse,

    -- * Response Lenses
    startImageScanResponse_imageId,
    startImageScanResponse_imageScanStatus,
    startImageScanResponse_registryId,
    startImageScanResponse_repositoryName,
    startImageScanResponse_httpStatus,
  )
where

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

-- | /See:/ 'newStartImageScan' smart constructor.
data StartImageScan = StartImageScan'
  { -- | The Amazon Web Services account ID associated with the registry that
    -- contains the repository in which to start an image scan request. If you
    -- do not specify a registry, the default registry is assumed.
    StartImageScan -> Maybe Text
registryId :: Prelude.Maybe Prelude.Text,
    -- | The name of the repository that contains the images to scan.
    StartImageScan -> Text
repositoryName :: Prelude.Text,
    StartImageScan -> ImageIdentifier
imageId :: ImageIdentifier
  }
  deriving (StartImageScan -> StartImageScan -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartImageScan -> StartImageScan -> Bool
$c/= :: StartImageScan -> StartImageScan -> Bool
== :: StartImageScan -> StartImageScan -> Bool
$c== :: StartImageScan -> StartImageScan -> Bool
Prelude.Eq, ReadPrec [StartImageScan]
ReadPrec StartImageScan
Int -> ReadS StartImageScan
ReadS [StartImageScan]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartImageScan]
$creadListPrec :: ReadPrec [StartImageScan]
readPrec :: ReadPrec StartImageScan
$creadPrec :: ReadPrec StartImageScan
readList :: ReadS [StartImageScan]
$creadList :: ReadS [StartImageScan]
readsPrec :: Int -> ReadS StartImageScan
$creadsPrec :: Int -> ReadS StartImageScan
Prelude.Read, Int -> StartImageScan -> ShowS
[StartImageScan] -> ShowS
StartImageScan -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartImageScan] -> ShowS
$cshowList :: [StartImageScan] -> ShowS
show :: StartImageScan -> String
$cshow :: StartImageScan -> String
showsPrec :: Int -> StartImageScan -> ShowS
$cshowsPrec :: Int -> StartImageScan -> ShowS
Prelude.Show, forall x. Rep StartImageScan x -> StartImageScan
forall x. StartImageScan -> Rep StartImageScan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartImageScan x -> StartImageScan
$cfrom :: forall x. StartImageScan -> Rep StartImageScan x
Prelude.Generic)

-- |
-- Create a value of 'StartImageScan' 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:
--
-- 'registryId', 'startImageScan_registryId' - The Amazon Web Services account ID associated with the registry that
-- contains the repository in which to start an image scan request. If you
-- do not specify a registry, the default registry is assumed.
--
-- 'repositoryName', 'startImageScan_repositoryName' - The name of the repository that contains the images to scan.
--
-- 'imageId', 'startImageScan_imageId' - Undocumented member.
newStartImageScan ::
  -- | 'repositoryName'
  Prelude.Text ->
  -- | 'imageId'
  ImageIdentifier ->
  StartImageScan
newStartImageScan :: Text -> ImageIdentifier -> StartImageScan
newStartImageScan Text
pRepositoryName_ ImageIdentifier
pImageId_ =
  StartImageScan'
    { $sel:registryId:StartImageScan' :: Maybe Text
registryId = forall a. Maybe a
Prelude.Nothing,
      $sel:repositoryName:StartImageScan' :: Text
repositoryName = Text
pRepositoryName_,
      $sel:imageId:StartImageScan' :: ImageIdentifier
imageId = ImageIdentifier
pImageId_
    }

-- | The Amazon Web Services account ID associated with the registry that
-- contains the repository in which to start an image scan request. If you
-- do not specify a registry, the default registry is assumed.
startImageScan_registryId :: Lens.Lens' StartImageScan (Prelude.Maybe Prelude.Text)
startImageScan_registryId :: Lens' StartImageScan (Maybe Text)
startImageScan_registryId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartImageScan' {Maybe Text
registryId :: Maybe Text
$sel:registryId:StartImageScan' :: StartImageScan -> Maybe Text
registryId} -> Maybe Text
registryId) (\s :: StartImageScan
s@StartImageScan' {} Maybe Text
a -> StartImageScan
s {$sel:registryId:StartImageScan' :: Maybe Text
registryId = Maybe Text
a} :: StartImageScan)

-- | The name of the repository that contains the images to scan.
startImageScan_repositoryName :: Lens.Lens' StartImageScan Prelude.Text
startImageScan_repositoryName :: Lens' StartImageScan Text
startImageScan_repositoryName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartImageScan' {Text
repositoryName :: Text
$sel:repositoryName:StartImageScan' :: StartImageScan -> Text
repositoryName} -> Text
repositoryName) (\s :: StartImageScan
s@StartImageScan' {} Text
a -> StartImageScan
s {$sel:repositoryName:StartImageScan' :: Text
repositoryName = Text
a} :: StartImageScan)

-- | Undocumented member.
startImageScan_imageId :: Lens.Lens' StartImageScan ImageIdentifier
startImageScan_imageId :: Lens' StartImageScan ImageIdentifier
startImageScan_imageId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartImageScan' {ImageIdentifier
imageId :: ImageIdentifier
$sel:imageId:StartImageScan' :: StartImageScan -> ImageIdentifier
imageId} -> ImageIdentifier
imageId) (\s :: StartImageScan
s@StartImageScan' {} ImageIdentifier
a -> StartImageScan
s {$sel:imageId:StartImageScan' :: ImageIdentifier
imageId = ImageIdentifier
a} :: StartImageScan)

instance Core.AWSRequest StartImageScan where
  type
    AWSResponse StartImageScan =
      StartImageScanResponse
  request :: (Service -> Service) -> StartImageScan -> Request StartImageScan
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy StartImageScan
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse StartImageScan)))
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 ImageIdentifier
-> Maybe ImageScanStatus
-> Maybe Text
-> Maybe Text
-> Int
-> StartImageScanResponse
StartImageScanResponse'
            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
"imageId")
            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
"imageScanStatus")
            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
"registryId")
            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
"repositoryName")
            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 StartImageScan where
  hashWithSalt :: Int -> StartImageScan -> Int
hashWithSalt Int
_salt StartImageScan' {Maybe Text
Text
ImageIdentifier
imageId :: ImageIdentifier
repositoryName :: Text
registryId :: Maybe Text
$sel:imageId:StartImageScan' :: StartImageScan -> ImageIdentifier
$sel:repositoryName:StartImageScan' :: StartImageScan -> Text
$sel:registryId:StartImageScan' :: StartImageScan -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
registryId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
repositoryName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ImageIdentifier
imageId

instance Prelude.NFData StartImageScan where
  rnf :: StartImageScan -> ()
rnf StartImageScan' {Maybe Text
Text
ImageIdentifier
imageId :: ImageIdentifier
repositoryName :: Text
registryId :: Maybe Text
$sel:imageId:StartImageScan' :: StartImageScan -> ImageIdentifier
$sel:repositoryName:StartImageScan' :: StartImageScan -> Text
$sel:registryId:StartImageScan' :: StartImageScan -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
registryId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
repositoryName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ImageIdentifier
imageId

instance Data.ToHeaders StartImageScan where
  toHeaders :: StartImageScan -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AmazonEC2ContainerRegistry_V20150921.StartImageScan" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON StartImageScan where
  toJSON :: StartImageScan -> Value
toJSON StartImageScan' {Maybe Text
Text
ImageIdentifier
imageId :: ImageIdentifier
repositoryName :: Text
registryId :: Maybe Text
$sel:imageId:StartImageScan' :: StartImageScan -> ImageIdentifier
$sel:repositoryName:StartImageScan' :: StartImageScan -> Text
$sel:registryId:StartImageScan' :: StartImageScan -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"registryId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
registryId,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"repositoryName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
repositoryName),
            forall a. a -> Maybe a
Prelude.Just (Key
"imageId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ImageIdentifier
imageId)
          ]
      )

instance Data.ToPath StartImageScan where
  toPath :: StartImageScan -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | /See:/ 'newStartImageScanResponse' smart constructor.
data StartImageScanResponse = StartImageScanResponse'
  { StartImageScanResponse -> Maybe ImageIdentifier
imageId :: Prelude.Maybe ImageIdentifier,
    -- | The current state of the scan.
    StartImageScanResponse -> Maybe ImageScanStatus
imageScanStatus :: Prelude.Maybe ImageScanStatus,
    -- | The registry ID associated with the request.
    StartImageScanResponse -> Maybe Text
registryId :: Prelude.Maybe Prelude.Text,
    -- | The repository name associated with the request.
    StartImageScanResponse -> Maybe Text
repositoryName :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    StartImageScanResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartImageScanResponse -> StartImageScanResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartImageScanResponse -> StartImageScanResponse -> Bool
$c/= :: StartImageScanResponse -> StartImageScanResponse -> Bool
== :: StartImageScanResponse -> StartImageScanResponse -> Bool
$c== :: StartImageScanResponse -> StartImageScanResponse -> Bool
Prelude.Eq, ReadPrec [StartImageScanResponse]
ReadPrec StartImageScanResponse
Int -> ReadS StartImageScanResponse
ReadS [StartImageScanResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartImageScanResponse]
$creadListPrec :: ReadPrec [StartImageScanResponse]
readPrec :: ReadPrec StartImageScanResponse
$creadPrec :: ReadPrec StartImageScanResponse
readList :: ReadS [StartImageScanResponse]
$creadList :: ReadS [StartImageScanResponse]
readsPrec :: Int -> ReadS StartImageScanResponse
$creadsPrec :: Int -> ReadS StartImageScanResponse
Prelude.Read, Int -> StartImageScanResponse -> ShowS
[StartImageScanResponse] -> ShowS
StartImageScanResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartImageScanResponse] -> ShowS
$cshowList :: [StartImageScanResponse] -> ShowS
show :: StartImageScanResponse -> String
$cshow :: StartImageScanResponse -> String
showsPrec :: Int -> StartImageScanResponse -> ShowS
$cshowsPrec :: Int -> StartImageScanResponse -> ShowS
Prelude.Show, forall x. Rep StartImageScanResponse x -> StartImageScanResponse
forall x. StartImageScanResponse -> Rep StartImageScanResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartImageScanResponse x -> StartImageScanResponse
$cfrom :: forall x. StartImageScanResponse -> Rep StartImageScanResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartImageScanResponse' 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:
--
-- 'imageId', 'startImageScanResponse_imageId' - Undocumented member.
--
-- 'imageScanStatus', 'startImageScanResponse_imageScanStatus' - The current state of the scan.
--
-- 'registryId', 'startImageScanResponse_registryId' - The registry ID associated with the request.
--
-- 'repositoryName', 'startImageScanResponse_repositoryName' - The repository name associated with the request.
--
-- 'httpStatus', 'startImageScanResponse_httpStatus' - The response's http status code.
newStartImageScanResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartImageScanResponse
newStartImageScanResponse :: Int -> StartImageScanResponse
newStartImageScanResponse Int
pHttpStatus_ =
  StartImageScanResponse'
    { $sel:imageId:StartImageScanResponse' :: Maybe ImageIdentifier
imageId = forall a. Maybe a
Prelude.Nothing,
      $sel:imageScanStatus:StartImageScanResponse' :: Maybe ImageScanStatus
imageScanStatus = forall a. Maybe a
Prelude.Nothing,
      $sel:registryId:StartImageScanResponse' :: Maybe Text
registryId = forall a. Maybe a
Prelude.Nothing,
      $sel:repositoryName:StartImageScanResponse' :: Maybe Text
repositoryName = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartImageScanResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
startImageScanResponse_imageId :: Lens.Lens' StartImageScanResponse (Prelude.Maybe ImageIdentifier)
startImageScanResponse_imageId :: Lens' StartImageScanResponse (Maybe ImageIdentifier)
startImageScanResponse_imageId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartImageScanResponse' {Maybe ImageIdentifier
imageId :: Maybe ImageIdentifier
$sel:imageId:StartImageScanResponse' :: StartImageScanResponse -> Maybe ImageIdentifier
imageId} -> Maybe ImageIdentifier
imageId) (\s :: StartImageScanResponse
s@StartImageScanResponse' {} Maybe ImageIdentifier
a -> StartImageScanResponse
s {$sel:imageId:StartImageScanResponse' :: Maybe ImageIdentifier
imageId = Maybe ImageIdentifier
a} :: StartImageScanResponse)

-- | The current state of the scan.
startImageScanResponse_imageScanStatus :: Lens.Lens' StartImageScanResponse (Prelude.Maybe ImageScanStatus)
startImageScanResponse_imageScanStatus :: Lens' StartImageScanResponse (Maybe ImageScanStatus)
startImageScanResponse_imageScanStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartImageScanResponse' {Maybe ImageScanStatus
imageScanStatus :: Maybe ImageScanStatus
$sel:imageScanStatus:StartImageScanResponse' :: StartImageScanResponse -> Maybe ImageScanStatus
imageScanStatus} -> Maybe ImageScanStatus
imageScanStatus) (\s :: StartImageScanResponse
s@StartImageScanResponse' {} Maybe ImageScanStatus
a -> StartImageScanResponse
s {$sel:imageScanStatus:StartImageScanResponse' :: Maybe ImageScanStatus
imageScanStatus = Maybe ImageScanStatus
a} :: StartImageScanResponse)

-- | The registry ID associated with the request.
startImageScanResponse_registryId :: Lens.Lens' StartImageScanResponse (Prelude.Maybe Prelude.Text)
startImageScanResponse_registryId :: Lens' StartImageScanResponse (Maybe Text)
startImageScanResponse_registryId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartImageScanResponse' {Maybe Text
registryId :: Maybe Text
$sel:registryId:StartImageScanResponse' :: StartImageScanResponse -> Maybe Text
registryId} -> Maybe Text
registryId) (\s :: StartImageScanResponse
s@StartImageScanResponse' {} Maybe Text
a -> StartImageScanResponse
s {$sel:registryId:StartImageScanResponse' :: Maybe Text
registryId = Maybe Text
a} :: StartImageScanResponse)

-- | The repository name associated with the request.
startImageScanResponse_repositoryName :: Lens.Lens' StartImageScanResponse (Prelude.Maybe Prelude.Text)
startImageScanResponse_repositoryName :: Lens' StartImageScanResponse (Maybe Text)
startImageScanResponse_repositoryName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartImageScanResponse' {Maybe Text
repositoryName :: Maybe Text
$sel:repositoryName:StartImageScanResponse' :: StartImageScanResponse -> Maybe Text
repositoryName} -> Maybe Text
repositoryName) (\s :: StartImageScanResponse
s@StartImageScanResponse' {} Maybe Text
a -> StartImageScanResponse
s {$sel:repositoryName:StartImageScanResponse' :: Maybe Text
repositoryName = Maybe Text
a} :: StartImageScanResponse)

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

instance Prelude.NFData StartImageScanResponse where
  rnf :: StartImageScanResponse -> ()
rnf StartImageScanResponse' {Int
Maybe Text
Maybe ImageIdentifier
Maybe ImageScanStatus
httpStatus :: Int
repositoryName :: Maybe Text
registryId :: Maybe Text
imageScanStatus :: Maybe ImageScanStatus
imageId :: Maybe ImageIdentifier
$sel:httpStatus:StartImageScanResponse' :: StartImageScanResponse -> Int
$sel:repositoryName:StartImageScanResponse' :: StartImageScanResponse -> Maybe Text
$sel:registryId:StartImageScanResponse' :: StartImageScanResponse -> Maybe Text
$sel:imageScanStatus:StartImageScanResponse' :: StartImageScanResponse -> Maybe ImageScanStatus
$sel:imageId:StartImageScanResponse' :: StartImageScanResponse -> Maybe ImageIdentifier
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ImageIdentifier
imageId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ImageScanStatus
imageScanStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
registryId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
repositoryName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus