{-# 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.Inspector2.EnableDelegatedAdminAccount
-- 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 the Amazon Inspector delegated administrator for your
-- Organizations organization.
module Amazonka.Inspector2.EnableDelegatedAdminAccount
  ( -- * Creating a Request
    EnableDelegatedAdminAccount (..),
    newEnableDelegatedAdminAccount,

    -- * Request Lenses
    enableDelegatedAdminAccount_clientToken,
    enableDelegatedAdminAccount_delegatedAdminAccountId,

    -- * Destructuring the Response
    EnableDelegatedAdminAccountResponse (..),
    newEnableDelegatedAdminAccountResponse,

    -- * Response Lenses
    enableDelegatedAdminAccountResponse_httpStatus,
    enableDelegatedAdminAccountResponse_delegatedAdminAccountId,
  )
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
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newEnableDelegatedAdminAccount' smart constructor.
data EnableDelegatedAdminAccount = EnableDelegatedAdminAccount'
  { -- | The idempotency token for the request.
    EnableDelegatedAdminAccount -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Web Services account ID of the Amazon Inspector delegated
    -- administrator.
    EnableDelegatedAdminAccount -> Text
delegatedAdminAccountId :: Prelude.Text
  }
  deriving (EnableDelegatedAdminAccount -> EnableDelegatedAdminAccount -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnableDelegatedAdminAccount -> EnableDelegatedAdminAccount -> Bool
$c/= :: EnableDelegatedAdminAccount -> EnableDelegatedAdminAccount -> Bool
== :: EnableDelegatedAdminAccount -> EnableDelegatedAdminAccount -> Bool
$c== :: EnableDelegatedAdminAccount -> EnableDelegatedAdminAccount -> Bool
Prelude.Eq, ReadPrec [EnableDelegatedAdminAccount]
ReadPrec EnableDelegatedAdminAccount
Int -> ReadS EnableDelegatedAdminAccount
ReadS [EnableDelegatedAdminAccount]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnableDelegatedAdminAccount]
$creadListPrec :: ReadPrec [EnableDelegatedAdminAccount]
readPrec :: ReadPrec EnableDelegatedAdminAccount
$creadPrec :: ReadPrec EnableDelegatedAdminAccount
readList :: ReadS [EnableDelegatedAdminAccount]
$creadList :: ReadS [EnableDelegatedAdminAccount]
readsPrec :: Int -> ReadS EnableDelegatedAdminAccount
$creadsPrec :: Int -> ReadS EnableDelegatedAdminAccount
Prelude.Read, Int -> EnableDelegatedAdminAccount -> ShowS
[EnableDelegatedAdminAccount] -> ShowS
EnableDelegatedAdminAccount -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnableDelegatedAdminAccount] -> ShowS
$cshowList :: [EnableDelegatedAdminAccount] -> ShowS
show :: EnableDelegatedAdminAccount -> String
$cshow :: EnableDelegatedAdminAccount -> String
showsPrec :: Int -> EnableDelegatedAdminAccount -> ShowS
$cshowsPrec :: Int -> EnableDelegatedAdminAccount -> ShowS
Prelude.Show, forall x.
Rep EnableDelegatedAdminAccount x -> EnableDelegatedAdminAccount
forall x.
EnableDelegatedAdminAccount -> Rep EnableDelegatedAdminAccount x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep EnableDelegatedAdminAccount x -> EnableDelegatedAdminAccount
$cfrom :: forall x.
EnableDelegatedAdminAccount -> Rep EnableDelegatedAdminAccount x
Prelude.Generic)

-- |
-- Create a value of 'EnableDelegatedAdminAccount' 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', 'enableDelegatedAdminAccount_clientToken' - The idempotency token for the request.
--
-- 'delegatedAdminAccountId', 'enableDelegatedAdminAccount_delegatedAdminAccountId' - The Amazon Web Services account ID of the Amazon Inspector delegated
-- administrator.
newEnableDelegatedAdminAccount ::
  -- | 'delegatedAdminAccountId'
  Prelude.Text ->
  EnableDelegatedAdminAccount
newEnableDelegatedAdminAccount :: Text -> EnableDelegatedAdminAccount
newEnableDelegatedAdminAccount
  Text
pDelegatedAdminAccountId_ =
    EnableDelegatedAdminAccount'
      { $sel:clientToken:EnableDelegatedAdminAccount' :: Maybe Text
clientToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:delegatedAdminAccountId:EnableDelegatedAdminAccount' :: Text
delegatedAdminAccountId =
          Text
pDelegatedAdminAccountId_
      }

-- | The idempotency token for the request.
enableDelegatedAdminAccount_clientToken :: Lens.Lens' EnableDelegatedAdminAccount (Prelude.Maybe Prelude.Text)
enableDelegatedAdminAccount_clientToken :: Lens' EnableDelegatedAdminAccount (Maybe Text)
enableDelegatedAdminAccount_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableDelegatedAdminAccount' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: EnableDelegatedAdminAccount
s@EnableDelegatedAdminAccount' {} Maybe Text
a -> EnableDelegatedAdminAccount
s {$sel:clientToken:EnableDelegatedAdminAccount' :: Maybe Text
clientToken = Maybe Text
a} :: EnableDelegatedAdminAccount)

-- | The Amazon Web Services account ID of the Amazon Inspector delegated
-- administrator.
enableDelegatedAdminAccount_delegatedAdminAccountId :: Lens.Lens' EnableDelegatedAdminAccount Prelude.Text
enableDelegatedAdminAccount_delegatedAdminAccountId :: Lens' EnableDelegatedAdminAccount Text
enableDelegatedAdminAccount_delegatedAdminAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableDelegatedAdminAccount' {Text
delegatedAdminAccountId :: Text
$sel:delegatedAdminAccountId:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> Text
delegatedAdminAccountId} -> Text
delegatedAdminAccountId) (\s :: EnableDelegatedAdminAccount
s@EnableDelegatedAdminAccount' {} Text
a -> EnableDelegatedAdminAccount
s {$sel:delegatedAdminAccountId:EnableDelegatedAdminAccount' :: Text
delegatedAdminAccountId = Text
a} :: EnableDelegatedAdminAccount)

instance Core.AWSRequest EnableDelegatedAdminAccount where
  type
    AWSResponse EnableDelegatedAdminAccount =
      EnableDelegatedAdminAccountResponse
  request :: (Service -> Service)
-> EnableDelegatedAdminAccount
-> Request EnableDelegatedAdminAccount
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 EnableDelegatedAdminAccount
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse EnableDelegatedAdminAccount)))
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 ->
          Int -> Text -> EnableDelegatedAdminAccountResponse
EnableDelegatedAdminAccountResponse'
            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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"delegatedAdminAccountId")
      )

instance Prelude.Hashable EnableDelegatedAdminAccount where
  hashWithSalt :: Int -> EnableDelegatedAdminAccount -> Int
hashWithSalt Int
_salt EnableDelegatedAdminAccount' {Maybe Text
Text
delegatedAdminAccountId :: Text
clientToken :: Maybe Text
$sel:delegatedAdminAccountId:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> Text
$sel:clientToken:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> 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` Text
delegatedAdminAccountId

instance Prelude.NFData EnableDelegatedAdminAccount where
  rnf :: EnableDelegatedAdminAccount -> ()
rnf EnableDelegatedAdminAccount' {Maybe Text
Text
delegatedAdminAccountId :: Text
clientToken :: Maybe Text
$sel:delegatedAdminAccountId:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> Text
$sel:clientToken:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> 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 Text
delegatedAdminAccountId

instance Data.ToHeaders EnableDelegatedAdminAccount where
  toHeaders :: EnableDelegatedAdminAccount -> 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 EnableDelegatedAdminAccount where
  toJSON :: EnableDelegatedAdminAccount -> Value
toJSON EnableDelegatedAdminAccount' {Maybe Text
Text
delegatedAdminAccountId :: Text
clientToken :: Maybe Text
$sel:delegatedAdminAccountId:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> Text
$sel:clientToken:EnableDelegatedAdminAccount' :: EnableDelegatedAdminAccount -> 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,
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"delegatedAdminAccountId"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
delegatedAdminAccountId
              )
          ]
      )

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

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

-- | /See:/ 'newEnableDelegatedAdminAccountResponse' smart constructor.
data EnableDelegatedAdminAccountResponse = EnableDelegatedAdminAccountResponse'
  { -- | The response's http status code.
    EnableDelegatedAdminAccountResponse -> Int
httpStatus :: Prelude.Int,
    -- | The Amazon Web Services account ID of the successfully Amazon Inspector
    -- delegated administrator.
    EnableDelegatedAdminAccountResponse -> Text
delegatedAdminAccountId :: Prelude.Text
  }
  deriving (EnableDelegatedAdminAccountResponse
-> EnableDelegatedAdminAccountResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnableDelegatedAdminAccountResponse
-> EnableDelegatedAdminAccountResponse -> Bool
$c/= :: EnableDelegatedAdminAccountResponse
-> EnableDelegatedAdminAccountResponse -> Bool
== :: EnableDelegatedAdminAccountResponse
-> EnableDelegatedAdminAccountResponse -> Bool
$c== :: EnableDelegatedAdminAccountResponse
-> EnableDelegatedAdminAccountResponse -> Bool
Prelude.Eq, ReadPrec [EnableDelegatedAdminAccountResponse]
ReadPrec EnableDelegatedAdminAccountResponse
Int -> ReadS EnableDelegatedAdminAccountResponse
ReadS [EnableDelegatedAdminAccountResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnableDelegatedAdminAccountResponse]
$creadListPrec :: ReadPrec [EnableDelegatedAdminAccountResponse]
readPrec :: ReadPrec EnableDelegatedAdminAccountResponse
$creadPrec :: ReadPrec EnableDelegatedAdminAccountResponse
readList :: ReadS [EnableDelegatedAdminAccountResponse]
$creadList :: ReadS [EnableDelegatedAdminAccountResponse]
readsPrec :: Int -> ReadS EnableDelegatedAdminAccountResponse
$creadsPrec :: Int -> ReadS EnableDelegatedAdminAccountResponse
Prelude.Read, Int -> EnableDelegatedAdminAccountResponse -> ShowS
[EnableDelegatedAdminAccountResponse] -> ShowS
EnableDelegatedAdminAccountResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnableDelegatedAdminAccountResponse] -> ShowS
$cshowList :: [EnableDelegatedAdminAccountResponse] -> ShowS
show :: EnableDelegatedAdminAccountResponse -> String
$cshow :: EnableDelegatedAdminAccountResponse -> String
showsPrec :: Int -> EnableDelegatedAdminAccountResponse -> ShowS
$cshowsPrec :: Int -> EnableDelegatedAdminAccountResponse -> ShowS
Prelude.Show, forall x.
Rep EnableDelegatedAdminAccountResponse x
-> EnableDelegatedAdminAccountResponse
forall x.
EnableDelegatedAdminAccountResponse
-> Rep EnableDelegatedAdminAccountResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep EnableDelegatedAdminAccountResponse x
-> EnableDelegatedAdminAccountResponse
$cfrom :: forall x.
EnableDelegatedAdminAccountResponse
-> Rep EnableDelegatedAdminAccountResponse x
Prelude.Generic)

-- |
-- Create a value of 'EnableDelegatedAdminAccountResponse' 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', 'enableDelegatedAdminAccountResponse_httpStatus' - The response's http status code.
--
-- 'delegatedAdminAccountId', 'enableDelegatedAdminAccountResponse_delegatedAdminAccountId' - The Amazon Web Services account ID of the successfully Amazon Inspector
-- delegated administrator.
newEnableDelegatedAdminAccountResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'delegatedAdminAccountId'
  Prelude.Text ->
  EnableDelegatedAdminAccountResponse
newEnableDelegatedAdminAccountResponse :: Int -> Text -> EnableDelegatedAdminAccountResponse
newEnableDelegatedAdminAccountResponse
  Int
pHttpStatus_
  Text
pDelegatedAdminAccountId_ =
    EnableDelegatedAdminAccountResponse'
      { $sel:httpStatus:EnableDelegatedAdminAccountResponse' :: Int
httpStatus =
          Int
pHttpStatus_,
        $sel:delegatedAdminAccountId:EnableDelegatedAdminAccountResponse' :: Text
delegatedAdminAccountId =
          Text
pDelegatedAdminAccountId_
      }

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

-- | The Amazon Web Services account ID of the successfully Amazon Inspector
-- delegated administrator.
enableDelegatedAdminAccountResponse_delegatedAdminAccountId :: Lens.Lens' EnableDelegatedAdminAccountResponse Prelude.Text
enableDelegatedAdminAccountResponse_delegatedAdminAccountId :: Lens' EnableDelegatedAdminAccountResponse Text
enableDelegatedAdminAccountResponse_delegatedAdminAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableDelegatedAdminAccountResponse' {Text
delegatedAdminAccountId :: Text
$sel:delegatedAdminAccountId:EnableDelegatedAdminAccountResponse' :: EnableDelegatedAdminAccountResponse -> Text
delegatedAdminAccountId} -> Text
delegatedAdminAccountId) (\s :: EnableDelegatedAdminAccountResponse
s@EnableDelegatedAdminAccountResponse' {} Text
a -> EnableDelegatedAdminAccountResponse
s {$sel:delegatedAdminAccountId:EnableDelegatedAdminAccountResponse' :: Text
delegatedAdminAccountId = Text
a} :: EnableDelegatedAdminAccountResponse)

instance
  Prelude.NFData
    EnableDelegatedAdminAccountResponse
  where
  rnf :: EnableDelegatedAdminAccountResponse -> ()
rnf EnableDelegatedAdminAccountResponse' {Int
Text
delegatedAdminAccountId :: Text
httpStatus :: Int
$sel:delegatedAdminAccountId:EnableDelegatedAdminAccountResponse' :: EnableDelegatedAdminAccountResponse -> Text
$sel:httpStatus:EnableDelegatedAdminAccountResponse' :: EnableDelegatedAdminAccountResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
delegatedAdminAccountId