{-# 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.MacieV2.EnableMacie
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Enables Amazon Macie and specifies the configuration settings for a
-- Macie account.
module Amazonka.MacieV2.EnableMacie
  ( -- * Creating a Request
    EnableMacie (..),
    newEnableMacie,

    -- * Request Lenses
    enableMacie_clientToken,
    enableMacie_findingPublishingFrequency,
    enableMacie_status,

    -- * Destructuring the Response
    EnableMacieResponse (..),
    newEnableMacieResponse,

    -- * Response Lenses
    enableMacieResponse_httpStatus,
  )
where

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

-- | /See:/ 'newEnableMacie' smart constructor.
data EnableMacie = EnableMacie'
  { -- | A unique, case-sensitive token that you provide to ensure the
    -- idempotency of the request.
    EnableMacie -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | Specifies how often to publish updates to policy findings for the
    -- account. This includes publishing updates to Security Hub and Amazon
    -- EventBridge (formerly Amazon CloudWatch Events).
    EnableMacie -> Maybe FindingPublishingFrequency
findingPublishingFrequency :: Prelude.Maybe FindingPublishingFrequency,
    -- | Specifies the new status for the account. To enable Amazon Macie and
    -- start all Macie activities for the account, set this value to ENABLED.
    EnableMacie -> Maybe MacieStatus
status :: Prelude.Maybe MacieStatus
  }
  deriving (EnableMacie -> EnableMacie -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnableMacie -> EnableMacie -> Bool
$c/= :: EnableMacie -> EnableMacie -> Bool
== :: EnableMacie -> EnableMacie -> Bool
$c== :: EnableMacie -> EnableMacie -> Bool
Prelude.Eq, ReadPrec [EnableMacie]
ReadPrec EnableMacie
Int -> ReadS EnableMacie
ReadS [EnableMacie]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnableMacie]
$creadListPrec :: ReadPrec [EnableMacie]
readPrec :: ReadPrec EnableMacie
$creadPrec :: ReadPrec EnableMacie
readList :: ReadS [EnableMacie]
$creadList :: ReadS [EnableMacie]
readsPrec :: Int -> ReadS EnableMacie
$creadsPrec :: Int -> ReadS EnableMacie
Prelude.Read, Int -> EnableMacie -> ShowS
[EnableMacie] -> ShowS
EnableMacie -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnableMacie] -> ShowS
$cshowList :: [EnableMacie] -> ShowS
show :: EnableMacie -> String
$cshow :: EnableMacie -> String
showsPrec :: Int -> EnableMacie -> ShowS
$cshowsPrec :: Int -> EnableMacie -> ShowS
Prelude.Show, forall x. Rep EnableMacie x -> EnableMacie
forall x. EnableMacie -> Rep EnableMacie x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep EnableMacie x -> EnableMacie
$cfrom :: forall x. EnableMacie -> Rep EnableMacie x
Prelude.Generic)

-- |
-- Create a value of 'EnableMacie' 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:
--
-- 'clientToken', 'enableMacie_clientToken' - A unique, case-sensitive token that you provide to ensure the
-- idempotency of the request.
--
-- 'findingPublishingFrequency', 'enableMacie_findingPublishingFrequency' - Specifies how often to publish updates to policy findings for the
-- account. This includes publishing updates to Security Hub and Amazon
-- EventBridge (formerly Amazon CloudWatch Events).
--
-- 'status', 'enableMacie_status' - Specifies the new status for the account. To enable Amazon Macie and
-- start all Macie activities for the account, set this value to ENABLED.
newEnableMacie ::
  EnableMacie
newEnableMacie :: EnableMacie
newEnableMacie =
  EnableMacie'
    { $sel:clientToken:EnableMacie' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:findingPublishingFrequency:EnableMacie' :: Maybe FindingPublishingFrequency
findingPublishingFrequency = forall a. Maybe a
Prelude.Nothing,
      $sel:status:EnableMacie' :: Maybe MacieStatus
status = forall a. Maybe a
Prelude.Nothing
    }

-- | A unique, case-sensitive token that you provide to ensure the
-- idempotency of the request.
enableMacie_clientToken :: Lens.Lens' EnableMacie (Prelude.Maybe Prelude.Text)
enableMacie_clientToken :: Lens' EnableMacie (Maybe Text)
enableMacie_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableMacie' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:EnableMacie' :: EnableMacie -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: EnableMacie
s@EnableMacie' {} Maybe Text
a -> EnableMacie
s {$sel:clientToken:EnableMacie' :: Maybe Text
clientToken = Maybe Text
a} :: EnableMacie)

-- | Specifies how often to publish updates to policy findings for the
-- account. This includes publishing updates to Security Hub and Amazon
-- EventBridge (formerly Amazon CloudWatch Events).
enableMacie_findingPublishingFrequency :: Lens.Lens' EnableMacie (Prelude.Maybe FindingPublishingFrequency)
enableMacie_findingPublishingFrequency :: Lens' EnableMacie (Maybe FindingPublishingFrequency)
enableMacie_findingPublishingFrequency = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableMacie' {Maybe FindingPublishingFrequency
findingPublishingFrequency :: Maybe FindingPublishingFrequency
$sel:findingPublishingFrequency:EnableMacie' :: EnableMacie -> Maybe FindingPublishingFrequency
findingPublishingFrequency} -> Maybe FindingPublishingFrequency
findingPublishingFrequency) (\s :: EnableMacie
s@EnableMacie' {} Maybe FindingPublishingFrequency
a -> EnableMacie
s {$sel:findingPublishingFrequency:EnableMacie' :: Maybe FindingPublishingFrequency
findingPublishingFrequency = Maybe FindingPublishingFrequency
a} :: EnableMacie)

-- | Specifies the new status for the account. To enable Amazon Macie and
-- start all Macie activities for the account, set this value to ENABLED.
enableMacie_status :: Lens.Lens' EnableMacie (Prelude.Maybe MacieStatus)
enableMacie_status :: Lens' EnableMacie (Maybe MacieStatus)
enableMacie_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableMacie' {Maybe MacieStatus
status :: Maybe MacieStatus
$sel:status:EnableMacie' :: EnableMacie -> Maybe MacieStatus
status} -> Maybe MacieStatus
status) (\s :: EnableMacie
s@EnableMacie' {} Maybe MacieStatus
a -> EnableMacie
s {$sel:status:EnableMacie' :: Maybe MacieStatus
status = Maybe MacieStatus
a} :: EnableMacie)

instance Core.AWSRequest EnableMacie where
  type AWSResponse EnableMacie = EnableMacieResponse
  request :: (Service -> Service) -> EnableMacie -> Request EnableMacie
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 EnableMacie
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse EnableMacie)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> EnableMacieResponse
EnableMacieResponse'
            forall (f :: * -> *) a b. Functor 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 EnableMacie where
  hashWithSalt :: Int -> EnableMacie -> Int
hashWithSalt Int
_salt EnableMacie' {Maybe Text
Maybe FindingPublishingFrequency
Maybe MacieStatus
status :: Maybe MacieStatus
findingPublishingFrequency :: Maybe FindingPublishingFrequency
clientToken :: Maybe Text
$sel:status:EnableMacie' :: EnableMacie -> Maybe MacieStatus
$sel:findingPublishingFrequency:EnableMacie' :: EnableMacie -> Maybe FindingPublishingFrequency
$sel:clientToken:EnableMacie' :: EnableMacie -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FindingPublishingFrequency
findingPublishingFrequency
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe MacieStatus
status

instance Prelude.NFData EnableMacie where
  rnf :: EnableMacie -> ()
rnf EnableMacie' {Maybe Text
Maybe FindingPublishingFrequency
Maybe MacieStatus
status :: Maybe MacieStatus
findingPublishingFrequency :: Maybe FindingPublishingFrequency
clientToken :: Maybe Text
$sel:status:EnableMacie' :: EnableMacie -> Maybe MacieStatus
$sel:findingPublishingFrequency:EnableMacie' :: EnableMacie -> Maybe FindingPublishingFrequency
$sel:clientToken:EnableMacie' :: EnableMacie -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FindingPublishingFrequency
findingPublishingFrequency
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe MacieStatus
status

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

instance Data.ToJSON EnableMacie where
  toJSON :: EnableMacie -> Value
toJSON EnableMacie' {Maybe Text
Maybe FindingPublishingFrequency
Maybe MacieStatus
status :: Maybe MacieStatus
findingPublishingFrequency :: Maybe FindingPublishingFrequency
clientToken :: Maybe Text
$sel:status:EnableMacie' :: EnableMacie -> Maybe MacieStatus
$sel:findingPublishingFrequency:EnableMacie' :: EnableMacie -> Maybe FindingPublishingFrequency
$sel:clientToken:EnableMacie' :: EnableMacie -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"clientToken" 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
clientToken,
            (Key
"findingPublishingFrequency" 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 FindingPublishingFrequency
findingPublishingFrequency,
            (Key
"status" 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 MacieStatus
status
          ]
      )

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

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

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

-- |
-- Create a value of 'EnableMacieResponse' 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:
--
-- 'httpStatus', 'enableMacieResponse_httpStatus' - The response's http status code.
newEnableMacieResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  EnableMacieResponse
newEnableMacieResponse :: Int -> EnableMacieResponse
newEnableMacieResponse Int
pHttpStatus_ =
  EnableMacieResponse' {$sel:httpStatus:EnableMacieResponse' :: Int
httpStatus = Int
pHttpStatus_}

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

instance Prelude.NFData EnableMacieResponse where
  rnf :: EnableMacieResponse -> ()
rnf EnableMacieResponse' {Int
httpStatus :: Int
$sel:httpStatus:EnableMacieResponse' :: EnableMacieResponse -> Int
..} = forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus