{-# 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.PutRegistryScanningConfiguration
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates or updates the scanning configuration for your private registry.
module Amazonka.ECR.PutRegistryScanningConfiguration
  ( -- * Creating a Request
    PutRegistryScanningConfiguration (..),
    newPutRegistryScanningConfiguration,

    -- * Request Lenses
    putRegistryScanningConfiguration_rules,
    putRegistryScanningConfiguration_scanType,

    -- * Destructuring the Response
    PutRegistryScanningConfigurationResponse (..),
    newPutRegistryScanningConfigurationResponse,

    -- * Response Lenses
    putRegistryScanningConfigurationResponse_registryScanningConfiguration,
    putRegistryScanningConfigurationResponse_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:/ 'newPutRegistryScanningConfiguration' smart constructor.
data PutRegistryScanningConfiguration = PutRegistryScanningConfiguration'
  { -- | The scanning rules to use for the registry. A scanning rule is used to
    -- determine which repository filters are used and at what frequency
    -- scanning will occur.
    PutRegistryScanningConfiguration -> Maybe [RegistryScanningRule]
rules :: Prelude.Maybe [RegistryScanningRule],
    -- | The scanning type to set for the registry.
    --
    -- When a registry scanning configuration is not defined, by default the
    -- @BASIC@ scan type is used. When basic scanning is used, you may specify
    -- filters to determine which individual repositories, or all repositories,
    -- are scanned when new images are pushed to those repositories.
    -- Alternatively, you can do manual scans of images with basic scanning.
    --
    -- When the @ENHANCED@ scan type is set, Amazon Inspector provides
    -- automated vulnerability scanning. You may choose between continuous
    -- scanning or scan on push and you may specify filters to determine which
    -- individual repositories, or all repositories, are scanned.
    PutRegistryScanningConfiguration -> Maybe ScanType
scanType :: Prelude.Maybe ScanType
  }
  deriving (PutRegistryScanningConfiguration
-> PutRegistryScanningConfiguration -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutRegistryScanningConfiguration
-> PutRegistryScanningConfiguration -> Bool
$c/= :: PutRegistryScanningConfiguration
-> PutRegistryScanningConfiguration -> Bool
== :: PutRegistryScanningConfiguration
-> PutRegistryScanningConfiguration -> Bool
$c== :: PutRegistryScanningConfiguration
-> PutRegistryScanningConfiguration -> Bool
Prelude.Eq, ReadPrec [PutRegistryScanningConfiguration]
ReadPrec PutRegistryScanningConfiguration
Int -> ReadS PutRegistryScanningConfiguration
ReadS [PutRegistryScanningConfiguration]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutRegistryScanningConfiguration]
$creadListPrec :: ReadPrec [PutRegistryScanningConfiguration]
readPrec :: ReadPrec PutRegistryScanningConfiguration
$creadPrec :: ReadPrec PutRegistryScanningConfiguration
readList :: ReadS [PutRegistryScanningConfiguration]
$creadList :: ReadS [PutRegistryScanningConfiguration]
readsPrec :: Int -> ReadS PutRegistryScanningConfiguration
$creadsPrec :: Int -> ReadS PutRegistryScanningConfiguration
Prelude.Read, Int -> PutRegistryScanningConfiguration -> ShowS
[PutRegistryScanningConfiguration] -> ShowS
PutRegistryScanningConfiguration -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutRegistryScanningConfiguration] -> ShowS
$cshowList :: [PutRegistryScanningConfiguration] -> ShowS
show :: PutRegistryScanningConfiguration -> String
$cshow :: PutRegistryScanningConfiguration -> String
showsPrec :: Int -> PutRegistryScanningConfiguration -> ShowS
$cshowsPrec :: Int -> PutRegistryScanningConfiguration -> ShowS
Prelude.Show, forall x.
Rep PutRegistryScanningConfiguration x
-> PutRegistryScanningConfiguration
forall x.
PutRegistryScanningConfiguration
-> Rep PutRegistryScanningConfiguration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep PutRegistryScanningConfiguration x
-> PutRegistryScanningConfiguration
$cfrom :: forall x.
PutRegistryScanningConfiguration
-> Rep PutRegistryScanningConfiguration x
Prelude.Generic)

-- |
-- Create a value of 'PutRegistryScanningConfiguration' 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:
--
-- 'rules', 'putRegistryScanningConfiguration_rules' - The scanning rules to use for the registry. A scanning rule is used to
-- determine which repository filters are used and at what frequency
-- scanning will occur.
--
-- 'scanType', 'putRegistryScanningConfiguration_scanType' - The scanning type to set for the registry.
--
-- When a registry scanning configuration is not defined, by default the
-- @BASIC@ scan type is used. When basic scanning is used, you may specify
-- filters to determine which individual repositories, or all repositories,
-- are scanned when new images are pushed to those repositories.
-- Alternatively, you can do manual scans of images with basic scanning.
--
-- When the @ENHANCED@ scan type is set, Amazon Inspector provides
-- automated vulnerability scanning. You may choose between continuous
-- scanning or scan on push and you may specify filters to determine which
-- individual repositories, or all repositories, are scanned.
newPutRegistryScanningConfiguration ::
  PutRegistryScanningConfiguration
newPutRegistryScanningConfiguration :: PutRegistryScanningConfiguration
newPutRegistryScanningConfiguration =
  PutRegistryScanningConfiguration'
    { $sel:rules:PutRegistryScanningConfiguration' :: Maybe [RegistryScanningRule]
rules =
        forall a. Maybe a
Prelude.Nothing,
      $sel:scanType:PutRegistryScanningConfiguration' :: Maybe ScanType
scanType = forall a. Maybe a
Prelude.Nothing
    }

-- | The scanning rules to use for the registry. A scanning rule is used to
-- determine which repository filters are used and at what frequency
-- scanning will occur.
putRegistryScanningConfiguration_rules :: Lens.Lens' PutRegistryScanningConfiguration (Prelude.Maybe [RegistryScanningRule])
putRegistryScanningConfiguration_rules :: Lens'
  PutRegistryScanningConfiguration (Maybe [RegistryScanningRule])
putRegistryScanningConfiguration_rules = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRegistryScanningConfiguration' {Maybe [RegistryScanningRule]
rules :: Maybe [RegistryScanningRule]
$sel:rules:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe [RegistryScanningRule]
rules} -> Maybe [RegistryScanningRule]
rules) (\s :: PutRegistryScanningConfiguration
s@PutRegistryScanningConfiguration' {} Maybe [RegistryScanningRule]
a -> PutRegistryScanningConfiguration
s {$sel:rules:PutRegistryScanningConfiguration' :: Maybe [RegistryScanningRule]
rules = Maybe [RegistryScanningRule]
a} :: PutRegistryScanningConfiguration) 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 scanning type to set for the registry.
--
-- When a registry scanning configuration is not defined, by default the
-- @BASIC@ scan type is used. When basic scanning is used, you may specify
-- filters to determine which individual repositories, or all repositories,
-- are scanned when new images are pushed to those repositories.
-- Alternatively, you can do manual scans of images with basic scanning.
--
-- When the @ENHANCED@ scan type is set, Amazon Inspector provides
-- automated vulnerability scanning. You may choose between continuous
-- scanning or scan on push and you may specify filters to determine which
-- individual repositories, or all repositories, are scanned.
putRegistryScanningConfiguration_scanType :: Lens.Lens' PutRegistryScanningConfiguration (Prelude.Maybe ScanType)
putRegistryScanningConfiguration_scanType :: Lens' PutRegistryScanningConfiguration (Maybe ScanType)
putRegistryScanningConfiguration_scanType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRegistryScanningConfiguration' {Maybe ScanType
scanType :: Maybe ScanType
$sel:scanType:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe ScanType
scanType} -> Maybe ScanType
scanType) (\s :: PutRegistryScanningConfiguration
s@PutRegistryScanningConfiguration' {} Maybe ScanType
a -> PutRegistryScanningConfiguration
s {$sel:scanType:PutRegistryScanningConfiguration' :: Maybe ScanType
scanType = Maybe ScanType
a} :: PutRegistryScanningConfiguration)

instance
  Core.AWSRequest
    PutRegistryScanningConfiguration
  where
  type
    AWSResponse PutRegistryScanningConfiguration =
      PutRegistryScanningConfigurationResponse
  request :: (Service -> Service)
-> PutRegistryScanningConfiguration
-> Request PutRegistryScanningConfiguration
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 PutRegistryScanningConfiguration
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse PutRegistryScanningConfiguration)))
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 RegistryScanningConfiguration
-> Int -> PutRegistryScanningConfigurationResponse
PutRegistryScanningConfigurationResponse'
            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
"registryScanningConfiguration")
            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
    PutRegistryScanningConfiguration
  where
  hashWithSalt :: Int -> PutRegistryScanningConfiguration -> Int
hashWithSalt
    Int
_salt
    PutRegistryScanningConfiguration' {Maybe [RegistryScanningRule]
Maybe ScanType
scanType :: Maybe ScanType
rules :: Maybe [RegistryScanningRule]
$sel:scanType:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe ScanType
$sel:rules:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe [RegistryScanningRule]
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [RegistryScanningRule]
rules
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ScanType
scanType

instance
  Prelude.NFData
    PutRegistryScanningConfiguration
  where
  rnf :: PutRegistryScanningConfiguration -> ()
rnf PutRegistryScanningConfiguration' {Maybe [RegistryScanningRule]
Maybe ScanType
scanType :: Maybe ScanType
rules :: Maybe [RegistryScanningRule]
$sel:scanType:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe ScanType
$sel:rules:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe [RegistryScanningRule]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [RegistryScanningRule]
rules
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ScanType
scanType

instance
  Data.ToHeaders
    PutRegistryScanningConfiguration
  where
  toHeaders :: PutRegistryScanningConfiguration -> 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.PutRegistryScanningConfiguration" ::
                          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 PutRegistryScanningConfiguration where
  toJSON :: PutRegistryScanningConfiguration -> Value
toJSON PutRegistryScanningConfiguration' {Maybe [RegistryScanningRule]
Maybe ScanType
scanType :: Maybe ScanType
rules :: Maybe [RegistryScanningRule]
$sel:scanType:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe ScanType
$sel:rules:PutRegistryScanningConfiguration' :: PutRegistryScanningConfiguration -> Maybe [RegistryScanningRule]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"rules" 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 [RegistryScanningRule]
rules,
            (Key
"scanType" 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 ScanType
scanType
          ]
      )

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

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

-- | /See:/ 'newPutRegistryScanningConfigurationResponse' smart constructor.
data PutRegistryScanningConfigurationResponse = PutRegistryScanningConfigurationResponse'
  { -- | The scanning configuration for your registry.
    PutRegistryScanningConfigurationResponse
-> Maybe RegistryScanningConfiguration
registryScanningConfiguration :: Prelude.Maybe RegistryScanningConfiguration,
    -- | The response's http status code.
    PutRegistryScanningConfigurationResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (PutRegistryScanningConfigurationResponse
-> PutRegistryScanningConfigurationResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutRegistryScanningConfigurationResponse
-> PutRegistryScanningConfigurationResponse -> Bool
$c/= :: PutRegistryScanningConfigurationResponse
-> PutRegistryScanningConfigurationResponse -> Bool
== :: PutRegistryScanningConfigurationResponse
-> PutRegistryScanningConfigurationResponse -> Bool
$c== :: PutRegistryScanningConfigurationResponse
-> PutRegistryScanningConfigurationResponse -> Bool
Prelude.Eq, ReadPrec [PutRegistryScanningConfigurationResponse]
ReadPrec PutRegistryScanningConfigurationResponse
Int -> ReadS PutRegistryScanningConfigurationResponse
ReadS [PutRegistryScanningConfigurationResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutRegistryScanningConfigurationResponse]
$creadListPrec :: ReadPrec [PutRegistryScanningConfigurationResponse]
readPrec :: ReadPrec PutRegistryScanningConfigurationResponse
$creadPrec :: ReadPrec PutRegistryScanningConfigurationResponse
readList :: ReadS [PutRegistryScanningConfigurationResponse]
$creadList :: ReadS [PutRegistryScanningConfigurationResponse]
readsPrec :: Int -> ReadS PutRegistryScanningConfigurationResponse
$creadsPrec :: Int -> ReadS PutRegistryScanningConfigurationResponse
Prelude.Read, Int -> PutRegistryScanningConfigurationResponse -> ShowS
[PutRegistryScanningConfigurationResponse] -> ShowS
PutRegistryScanningConfigurationResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutRegistryScanningConfigurationResponse] -> ShowS
$cshowList :: [PutRegistryScanningConfigurationResponse] -> ShowS
show :: PutRegistryScanningConfigurationResponse -> String
$cshow :: PutRegistryScanningConfigurationResponse -> String
showsPrec :: Int -> PutRegistryScanningConfigurationResponse -> ShowS
$cshowsPrec :: Int -> PutRegistryScanningConfigurationResponse -> ShowS
Prelude.Show, forall x.
Rep PutRegistryScanningConfigurationResponse x
-> PutRegistryScanningConfigurationResponse
forall x.
PutRegistryScanningConfigurationResponse
-> Rep PutRegistryScanningConfigurationResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep PutRegistryScanningConfigurationResponse x
-> PutRegistryScanningConfigurationResponse
$cfrom :: forall x.
PutRegistryScanningConfigurationResponse
-> Rep PutRegistryScanningConfigurationResponse x
Prelude.Generic)

-- |
-- Create a value of 'PutRegistryScanningConfigurationResponse' 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:
--
-- 'registryScanningConfiguration', 'putRegistryScanningConfigurationResponse_registryScanningConfiguration' - The scanning configuration for your registry.
--
-- 'httpStatus', 'putRegistryScanningConfigurationResponse_httpStatus' - The response's http status code.
newPutRegistryScanningConfigurationResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PutRegistryScanningConfigurationResponse
newPutRegistryScanningConfigurationResponse :: Int -> PutRegistryScanningConfigurationResponse
newPutRegistryScanningConfigurationResponse
  Int
pHttpStatus_ =
    PutRegistryScanningConfigurationResponse'
      { $sel:registryScanningConfiguration:PutRegistryScanningConfigurationResponse' :: Maybe RegistryScanningConfiguration
registryScanningConfiguration =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:PutRegistryScanningConfigurationResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | The scanning configuration for your registry.
putRegistryScanningConfigurationResponse_registryScanningConfiguration :: Lens.Lens' PutRegistryScanningConfigurationResponse (Prelude.Maybe RegistryScanningConfiguration)
putRegistryScanningConfigurationResponse_registryScanningConfiguration :: Lens'
  PutRegistryScanningConfigurationResponse
  (Maybe RegistryScanningConfiguration)
putRegistryScanningConfigurationResponse_registryScanningConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRegistryScanningConfigurationResponse' {Maybe RegistryScanningConfiguration
registryScanningConfiguration :: Maybe RegistryScanningConfiguration
$sel:registryScanningConfiguration:PutRegistryScanningConfigurationResponse' :: PutRegistryScanningConfigurationResponse
-> Maybe RegistryScanningConfiguration
registryScanningConfiguration} -> Maybe RegistryScanningConfiguration
registryScanningConfiguration) (\s :: PutRegistryScanningConfigurationResponse
s@PutRegistryScanningConfigurationResponse' {} Maybe RegistryScanningConfiguration
a -> PutRegistryScanningConfigurationResponse
s {$sel:registryScanningConfiguration:PutRegistryScanningConfigurationResponse' :: Maybe RegistryScanningConfiguration
registryScanningConfiguration = Maybe RegistryScanningConfiguration
a} :: PutRegistryScanningConfigurationResponse)

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

instance
  Prelude.NFData
    PutRegistryScanningConfigurationResponse
  where
  rnf :: PutRegistryScanningConfigurationResponse -> ()
rnf PutRegistryScanningConfigurationResponse' {Int
Maybe RegistryScanningConfiguration
httpStatus :: Int
registryScanningConfiguration :: Maybe RegistryScanningConfiguration
$sel:httpStatus:PutRegistryScanningConfigurationResponse' :: PutRegistryScanningConfigurationResponse -> Int
$sel:registryScanningConfiguration:PutRegistryScanningConfigurationResponse' :: PutRegistryScanningConfigurationResponse
-> Maybe RegistryScanningConfiguration
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe RegistryScanningConfiguration
registryScanningConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus