{-# 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.EC2.EnableIpamOrganizationAdminAccount
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Enable an Organizations member account as the IPAM admin account. You
-- cannot select the Organizations management account as the IPAM admin
-- account. For more information, see
-- <https://docs.aws.amazon.com/vpc/latest/ipam/enable-integ-ipam.html Enable integration with Organizations>
-- in the /Amazon VPC IPAM User Guide/.
module Amazonka.EC2.EnableIpamOrganizationAdminAccount
  ( -- * Creating a Request
    EnableIpamOrganizationAdminAccount (..),
    newEnableIpamOrganizationAdminAccount,

    -- * Request Lenses
    enableIpamOrganizationAdminAccount_dryRun,
    enableIpamOrganizationAdminAccount_delegatedAdminAccountId,

    -- * Destructuring the Response
    EnableIpamOrganizationAdminAccountResponse (..),
    newEnableIpamOrganizationAdminAccountResponse,

    -- * Response Lenses
    enableIpamOrganizationAdminAccountResponse_success,
    enableIpamOrganizationAdminAccountResponse_httpStatus,
  )
where

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

-- | /See:/ 'newEnableIpamOrganizationAdminAccount' smart constructor.
data EnableIpamOrganizationAdminAccount = EnableIpamOrganizationAdminAccount'
  { -- | A check for whether you have the required permissions for the action
    -- without actually making the request and provides an error response. If
    -- you have the required permissions, the error response is
    -- @DryRunOperation@. Otherwise, it is @UnauthorizedOperation@.
    EnableIpamOrganizationAdminAccount -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The Organizations member account ID that you want to enable as the IPAM
    -- account.
    EnableIpamOrganizationAdminAccount -> Text
delegatedAdminAccountId :: Prelude.Text
  }
  deriving (EnableIpamOrganizationAdminAccount
-> EnableIpamOrganizationAdminAccount -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnableIpamOrganizationAdminAccount
-> EnableIpamOrganizationAdminAccount -> Bool
$c/= :: EnableIpamOrganizationAdminAccount
-> EnableIpamOrganizationAdminAccount -> Bool
== :: EnableIpamOrganizationAdminAccount
-> EnableIpamOrganizationAdminAccount -> Bool
$c== :: EnableIpamOrganizationAdminAccount
-> EnableIpamOrganizationAdminAccount -> Bool
Prelude.Eq, ReadPrec [EnableIpamOrganizationAdminAccount]
ReadPrec EnableIpamOrganizationAdminAccount
Int -> ReadS EnableIpamOrganizationAdminAccount
ReadS [EnableIpamOrganizationAdminAccount]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnableIpamOrganizationAdminAccount]
$creadListPrec :: ReadPrec [EnableIpamOrganizationAdminAccount]
readPrec :: ReadPrec EnableIpamOrganizationAdminAccount
$creadPrec :: ReadPrec EnableIpamOrganizationAdminAccount
readList :: ReadS [EnableIpamOrganizationAdminAccount]
$creadList :: ReadS [EnableIpamOrganizationAdminAccount]
readsPrec :: Int -> ReadS EnableIpamOrganizationAdminAccount
$creadsPrec :: Int -> ReadS EnableIpamOrganizationAdminAccount
Prelude.Read, Int -> EnableIpamOrganizationAdminAccount -> ShowS
[EnableIpamOrganizationAdminAccount] -> ShowS
EnableIpamOrganizationAdminAccount -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnableIpamOrganizationAdminAccount] -> ShowS
$cshowList :: [EnableIpamOrganizationAdminAccount] -> ShowS
show :: EnableIpamOrganizationAdminAccount -> String
$cshow :: EnableIpamOrganizationAdminAccount -> String
showsPrec :: Int -> EnableIpamOrganizationAdminAccount -> ShowS
$cshowsPrec :: Int -> EnableIpamOrganizationAdminAccount -> ShowS
Prelude.Show, forall x.
Rep EnableIpamOrganizationAdminAccount x
-> EnableIpamOrganizationAdminAccount
forall x.
EnableIpamOrganizationAdminAccount
-> Rep EnableIpamOrganizationAdminAccount x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep EnableIpamOrganizationAdminAccount x
-> EnableIpamOrganizationAdminAccount
$cfrom :: forall x.
EnableIpamOrganizationAdminAccount
-> Rep EnableIpamOrganizationAdminAccount x
Prelude.Generic)

-- |
-- Create a value of 'EnableIpamOrganizationAdminAccount' 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:
--
-- 'dryRun', 'enableIpamOrganizationAdminAccount_dryRun' - A check for whether you have the required permissions for the action
-- without actually making the request and provides an error response. If
-- you have the required permissions, the error response is
-- @DryRunOperation@. Otherwise, it is @UnauthorizedOperation@.
--
-- 'delegatedAdminAccountId', 'enableIpamOrganizationAdminAccount_delegatedAdminAccountId' - The Organizations member account ID that you want to enable as the IPAM
-- account.
newEnableIpamOrganizationAdminAccount ::
  -- | 'delegatedAdminAccountId'
  Prelude.Text ->
  EnableIpamOrganizationAdminAccount
newEnableIpamOrganizationAdminAccount :: Text -> EnableIpamOrganizationAdminAccount
newEnableIpamOrganizationAdminAccount
  Text
pDelegatedAdminAccountId_ =
    EnableIpamOrganizationAdminAccount'
      { $sel:dryRun:EnableIpamOrganizationAdminAccount' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:delegatedAdminAccountId:EnableIpamOrganizationAdminAccount' :: Text
delegatedAdminAccountId =
          Text
pDelegatedAdminAccountId_
      }

-- | A check for whether you have the required permissions for the action
-- without actually making the request and provides an error response. If
-- you have the required permissions, the error response is
-- @DryRunOperation@. Otherwise, it is @UnauthorizedOperation@.
enableIpamOrganizationAdminAccount_dryRun :: Lens.Lens' EnableIpamOrganizationAdminAccount (Prelude.Maybe Prelude.Bool)
enableIpamOrganizationAdminAccount_dryRun :: Lens' EnableIpamOrganizationAdminAccount (Maybe Bool)
enableIpamOrganizationAdminAccount_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableIpamOrganizationAdminAccount' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: EnableIpamOrganizationAdminAccount
s@EnableIpamOrganizationAdminAccount' {} Maybe Bool
a -> EnableIpamOrganizationAdminAccount
s {$sel:dryRun:EnableIpamOrganizationAdminAccount' :: Maybe Bool
dryRun = Maybe Bool
a} :: EnableIpamOrganizationAdminAccount)

-- | The Organizations member account ID that you want to enable as the IPAM
-- account.
enableIpamOrganizationAdminAccount_delegatedAdminAccountId :: Lens.Lens' EnableIpamOrganizationAdminAccount Prelude.Text
enableIpamOrganizationAdminAccount_delegatedAdminAccountId :: Lens' EnableIpamOrganizationAdminAccount Text
enableIpamOrganizationAdminAccount_delegatedAdminAccountId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableIpamOrganizationAdminAccount' {Text
delegatedAdminAccountId :: Text
$sel:delegatedAdminAccountId:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Text
delegatedAdminAccountId} -> Text
delegatedAdminAccountId) (\s :: EnableIpamOrganizationAdminAccount
s@EnableIpamOrganizationAdminAccount' {} Text
a -> EnableIpamOrganizationAdminAccount
s {$sel:delegatedAdminAccountId:EnableIpamOrganizationAdminAccount' :: Text
delegatedAdminAccountId = Text
a} :: EnableIpamOrganizationAdminAccount)

instance
  Core.AWSRequest
    EnableIpamOrganizationAdminAccount
  where
  type
    AWSResponse EnableIpamOrganizationAdminAccount =
      EnableIpamOrganizationAdminAccountResponse
  request :: (Service -> Service)
-> EnableIpamOrganizationAdminAccount
-> Request EnableIpamOrganizationAdminAccount
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy EnableIpamOrganizationAdminAccount
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse EnableIpamOrganizationAdminAccount)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe Bool -> Int -> EnableIpamOrganizationAdminAccountResponse
EnableIpamOrganizationAdminAccountResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"success")
            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
    EnableIpamOrganizationAdminAccount
  where
  hashWithSalt :: Int -> EnableIpamOrganizationAdminAccount -> Int
hashWithSalt
    Int
_salt
    EnableIpamOrganizationAdminAccount' {Maybe Bool
Text
delegatedAdminAccountId :: Text
dryRun :: Maybe Bool
$sel:delegatedAdminAccountId:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Text
$sel:dryRun:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Maybe Bool
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
delegatedAdminAccountId

instance
  Prelude.NFData
    EnableIpamOrganizationAdminAccount
  where
  rnf :: EnableIpamOrganizationAdminAccount -> ()
rnf EnableIpamOrganizationAdminAccount' {Maybe Bool
Text
delegatedAdminAccountId :: Text
dryRun :: Maybe Bool
$sel:delegatedAdminAccountId:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Text
$sel:dryRun:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
delegatedAdminAccountId

instance
  Data.ToHeaders
    EnableIpamOrganizationAdminAccount
  where
  toHeaders :: EnableIpamOrganizationAdminAccount -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance
  Data.ToQuery
    EnableIpamOrganizationAdminAccount
  where
  toQuery :: EnableIpamOrganizationAdminAccount -> QueryString
toQuery EnableIpamOrganizationAdminAccount' {Maybe Bool
Text
delegatedAdminAccountId :: Text
dryRun :: Maybe Bool
$sel:delegatedAdminAccountId:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Text
$sel:dryRun:EnableIpamOrganizationAdminAccount' :: EnableIpamOrganizationAdminAccount -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"EnableIpamOrganizationAdminAccount" ::
                      Prelude.ByteString
                  ),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        ByteString
"DelegatedAdminAccountId"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
delegatedAdminAccountId
      ]

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

-- |
-- Create a value of 'EnableIpamOrganizationAdminAccountResponse' 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:
--
-- 'success', 'enableIpamOrganizationAdminAccountResponse_success' - The result of enabling the IPAM account.
--
-- 'httpStatus', 'enableIpamOrganizationAdminAccountResponse_httpStatus' - The response's http status code.
newEnableIpamOrganizationAdminAccountResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  EnableIpamOrganizationAdminAccountResponse
newEnableIpamOrganizationAdminAccountResponse :: Int -> EnableIpamOrganizationAdminAccountResponse
newEnableIpamOrganizationAdminAccountResponse
  Int
pHttpStatus_ =
    EnableIpamOrganizationAdminAccountResponse'
      { $sel:success:EnableIpamOrganizationAdminAccountResponse' :: Maybe Bool
success =
          forall a. Maybe a
Prelude.Nothing,
        $sel:httpStatus:EnableIpamOrganizationAdminAccountResponse' :: Int
httpStatus = Int
pHttpStatus_
      }

-- | The result of enabling the IPAM account.
enableIpamOrganizationAdminAccountResponse_success :: Lens.Lens' EnableIpamOrganizationAdminAccountResponse (Prelude.Maybe Prelude.Bool)
enableIpamOrganizationAdminAccountResponse_success :: Lens' EnableIpamOrganizationAdminAccountResponse (Maybe Bool)
enableIpamOrganizationAdminAccountResponse_success = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\EnableIpamOrganizationAdminAccountResponse' {Maybe Bool
success :: Maybe Bool
$sel:success:EnableIpamOrganizationAdminAccountResponse' :: EnableIpamOrganizationAdminAccountResponse -> Maybe Bool
success} -> Maybe Bool
success) (\s :: EnableIpamOrganizationAdminAccountResponse
s@EnableIpamOrganizationAdminAccountResponse' {} Maybe Bool
a -> EnableIpamOrganizationAdminAccountResponse
s {$sel:success:EnableIpamOrganizationAdminAccountResponse' :: Maybe Bool
success = Maybe Bool
a} :: EnableIpamOrganizationAdminAccountResponse)

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

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