{-# 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.DisableIpamOrganizationAdminAccount
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Disable the IPAM 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.DisableIpamOrganizationAdminAccount
  ( -- * Creating a Request
    DisableIpamOrganizationAdminAccount (..),
    newDisableIpamOrganizationAdminAccount,

    -- * Request Lenses
    disableIpamOrganizationAdminAccount_dryRun,
    disableIpamOrganizationAdminAccount_delegatedAdminAccountId,

    -- * Destructuring the Response
    DisableIpamOrganizationAdminAccountResponse (..),
    newDisableIpamOrganizationAdminAccountResponse,

    -- * Response Lenses
    disableIpamOrganizationAdminAccountResponse_success,
    disableIpamOrganizationAdminAccountResponse_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:/ 'newDisableIpamOrganizationAdminAccount' smart constructor.
data DisableIpamOrganizationAdminAccount = DisableIpamOrganizationAdminAccount'
  { -- | 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@.
    DisableIpamOrganizationAdminAccount -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The Organizations member account ID that you want to disable as IPAM
    -- account.
    DisableIpamOrganizationAdminAccount -> Text
delegatedAdminAccountId :: Prelude.Text
  }
  deriving (DisableIpamOrganizationAdminAccount
-> DisableIpamOrganizationAdminAccount -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisableIpamOrganizationAdminAccount
-> DisableIpamOrganizationAdminAccount -> Bool
$c/= :: DisableIpamOrganizationAdminAccount
-> DisableIpamOrganizationAdminAccount -> Bool
== :: DisableIpamOrganizationAdminAccount
-> DisableIpamOrganizationAdminAccount -> Bool
$c== :: DisableIpamOrganizationAdminAccount
-> DisableIpamOrganizationAdminAccount -> Bool
Prelude.Eq, ReadPrec [DisableIpamOrganizationAdminAccount]
ReadPrec DisableIpamOrganizationAdminAccount
Int -> ReadS DisableIpamOrganizationAdminAccount
ReadS [DisableIpamOrganizationAdminAccount]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DisableIpamOrganizationAdminAccount]
$creadListPrec :: ReadPrec [DisableIpamOrganizationAdminAccount]
readPrec :: ReadPrec DisableIpamOrganizationAdminAccount
$creadPrec :: ReadPrec DisableIpamOrganizationAdminAccount
readList :: ReadS [DisableIpamOrganizationAdminAccount]
$creadList :: ReadS [DisableIpamOrganizationAdminAccount]
readsPrec :: Int -> ReadS DisableIpamOrganizationAdminAccount
$creadsPrec :: Int -> ReadS DisableIpamOrganizationAdminAccount
Prelude.Read, Int -> DisableIpamOrganizationAdminAccount -> ShowS
[DisableIpamOrganizationAdminAccount] -> ShowS
DisableIpamOrganizationAdminAccount -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DisableIpamOrganizationAdminAccount] -> ShowS
$cshowList :: [DisableIpamOrganizationAdminAccount] -> ShowS
show :: DisableIpamOrganizationAdminAccount -> String
$cshow :: DisableIpamOrganizationAdminAccount -> String
showsPrec :: Int -> DisableIpamOrganizationAdminAccount -> ShowS
$cshowsPrec :: Int -> DisableIpamOrganizationAdminAccount -> ShowS
Prelude.Show, forall x.
Rep DisableIpamOrganizationAdminAccount x
-> DisableIpamOrganizationAdminAccount
forall x.
DisableIpamOrganizationAdminAccount
-> Rep DisableIpamOrganizationAdminAccount x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DisableIpamOrganizationAdminAccount x
-> DisableIpamOrganizationAdminAccount
$cfrom :: forall x.
DisableIpamOrganizationAdminAccount
-> Rep DisableIpamOrganizationAdminAccount x
Prelude.Generic)

-- |
-- Create a value of 'DisableIpamOrganizationAdminAccount' 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', 'disableIpamOrganizationAdminAccount_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', 'disableIpamOrganizationAdminAccount_delegatedAdminAccountId' - The Organizations member account ID that you want to disable as IPAM
-- account.
newDisableIpamOrganizationAdminAccount ::
  -- | 'delegatedAdminAccountId'
  Prelude.Text ->
  DisableIpamOrganizationAdminAccount
newDisableIpamOrganizationAdminAccount :: Text -> DisableIpamOrganizationAdminAccount
newDisableIpamOrganizationAdminAccount
  Text
pDelegatedAdminAccountId_ =
    DisableIpamOrganizationAdminAccount'
      { $sel:dryRun:DisableIpamOrganizationAdminAccount' :: Maybe Bool
dryRun =
          forall a. Maybe a
Prelude.Nothing,
        $sel:delegatedAdminAccountId:DisableIpamOrganizationAdminAccount' :: 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@.
disableIpamOrganizationAdminAccount_dryRun :: Lens.Lens' DisableIpamOrganizationAdminAccount (Prelude.Maybe Prelude.Bool)
disableIpamOrganizationAdminAccount_dryRun :: Lens' DisableIpamOrganizationAdminAccount (Maybe Bool)
disableIpamOrganizationAdminAccount_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DisableIpamOrganizationAdminAccount' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:DisableIpamOrganizationAdminAccount' :: DisableIpamOrganizationAdminAccount -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: DisableIpamOrganizationAdminAccount
s@DisableIpamOrganizationAdminAccount' {} Maybe Bool
a -> DisableIpamOrganizationAdminAccount
s {$sel:dryRun:DisableIpamOrganizationAdminAccount' :: Maybe Bool
dryRun = Maybe Bool
a} :: DisableIpamOrganizationAdminAccount)

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

instance
  Core.AWSRequest
    DisableIpamOrganizationAdminAccount
  where
  type
    AWSResponse DisableIpamOrganizationAdminAccount =
      DisableIpamOrganizationAdminAccountResponse
  request :: (Service -> Service)
-> DisableIpamOrganizationAdminAccount
-> Request DisableIpamOrganizationAdminAccount
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 DisableIpamOrganizationAdminAccount
-> ClientResponse ClientBody
-> m (Either
        Error
        (ClientResponse (AWSResponse DisableIpamOrganizationAdminAccount)))
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 -> DisableIpamOrganizationAdminAccountResponse
DisableIpamOrganizationAdminAccountResponse'
            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
    DisableIpamOrganizationAdminAccount
  where
  hashWithSalt :: Int -> DisableIpamOrganizationAdminAccount -> Int
hashWithSalt
    Int
_salt
    DisableIpamOrganizationAdminAccount' {Maybe Bool
Text
delegatedAdminAccountId :: Text
dryRun :: Maybe Bool
$sel:delegatedAdminAccountId:DisableIpamOrganizationAdminAccount' :: DisableIpamOrganizationAdminAccount -> Text
$sel:dryRun:DisableIpamOrganizationAdminAccount' :: DisableIpamOrganizationAdminAccount -> 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
    DisableIpamOrganizationAdminAccount
  where
  rnf :: DisableIpamOrganizationAdminAccount -> ()
rnf DisableIpamOrganizationAdminAccount' {Maybe Bool
Text
delegatedAdminAccountId :: Text
dryRun :: Maybe Bool
$sel:delegatedAdminAccountId:DisableIpamOrganizationAdminAccount' :: DisableIpamOrganizationAdminAccount -> Text
$sel:dryRun:DisableIpamOrganizationAdminAccount' :: DisableIpamOrganizationAdminAccount -> 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
    DisableIpamOrganizationAdminAccount
  where
  toHeaders :: DisableIpamOrganizationAdminAccount -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance
  Data.ToQuery
    DisableIpamOrganizationAdminAccount
  where
  toQuery :: DisableIpamOrganizationAdminAccount -> QueryString
toQuery DisableIpamOrganizationAdminAccount' {Maybe Bool
Text
delegatedAdminAccountId :: Text
dryRun :: Maybe Bool
$sel:delegatedAdminAccountId:DisableIpamOrganizationAdminAccount' :: DisableIpamOrganizationAdminAccount -> Text
$sel:dryRun:DisableIpamOrganizationAdminAccount' :: DisableIpamOrganizationAdminAccount -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"DisableIpamOrganizationAdminAccount" ::
                      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:/ 'newDisableIpamOrganizationAdminAccountResponse' smart constructor.
data DisableIpamOrganizationAdminAccountResponse = DisableIpamOrganizationAdminAccountResponse'
  { -- | The result of disabling the IPAM account.
    DisableIpamOrganizationAdminAccountResponse -> Maybe Bool
success :: Prelude.Maybe Prelude.Bool,
    -- | The response's http status code.
    DisableIpamOrganizationAdminAccountResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DisableIpamOrganizationAdminAccountResponse
-> DisableIpamOrganizationAdminAccountResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DisableIpamOrganizationAdminAccountResponse
-> DisableIpamOrganizationAdminAccountResponse -> Bool
$c/= :: DisableIpamOrganizationAdminAccountResponse
-> DisableIpamOrganizationAdminAccountResponse -> Bool
== :: DisableIpamOrganizationAdminAccountResponse
-> DisableIpamOrganizationAdminAccountResponse -> Bool
$c== :: DisableIpamOrganizationAdminAccountResponse
-> DisableIpamOrganizationAdminAccountResponse -> Bool
Prelude.Eq, ReadPrec [DisableIpamOrganizationAdminAccountResponse]
ReadPrec DisableIpamOrganizationAdminAccountResponse
Int -> ReadS DisableIpamOrganizationAdminAccountResponse
ReadS [DisableIpamOrganizationAdminAccountResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DisableIpamOrganizationAdminAccountResponse]
$creadListPrec :: ReadPrec [DisableIpamOrganizationAdminAccountResponse]
readPrec :: ReadPrec DisableIpamOrganizationAdminAccountResponse
$creadPrec :: ReadPrec DisableIpamOrganizationAdminAccountResponse
readList :: ReadS [DisableIpamOrganizationAdminAccountResponse]
$creadList :: ReadS [DisableIpamOrganizationAdminAccountResponse]
readsPrec :: Int -> ReadS DisableIpamOrganizationAdminAccountResponse
$creadsPrec :: Int -> ReadS DisableIpamOrganizationAdminAccountResponse
Prelude.Read, Int -> DisableIpamOrganizationAdminAccountResponse -> ShowS
[DisableIpamOrganizationAdminAccountResponse] -> ShowS
DisableIpamOrganizationAdminAccountResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DisableIpamOrganizationAdminAccountResponse] -> ShowS
$cshowList :: [DisableIpamOrganizationAdminAccountResponse] -> ShowS
show :: DisableIpamOrganizationAdminAccountResponse -> String
$cshow :: DisableIpamOrganizationAdminAccountResponse -> String
showsPrec :: Int -> DisableIpamOrganizationAdminAccountResponse -> ShowS
$cshowsPrec :: Int -> DisableIpamOrganizationAdminAccountResponse -> ShowS
Prelude.Show, forall x.
Rep DisableIpamOrganizationAdminAccountResponse x
-> DisableIpamOrganizationAdminAccountResponse
forall x.
DisableIpamOrganizationAdminAccountResponse
-> Rep DisableIpamOrganizationAdminAccountResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DisableIpamOrganizationAdminAccountResponse x
-> DisableIpamOrganizationAdminAccountResponse
$cfrom :: forall x.
DisableIpamOrganizationAdminAccountResponse
-> Rep DisableIpamOrganizationAdminAccountResponse x
Prelude.Generic)

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

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

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

instance
  Prelude.NFData
    DisableIpamOrganizationAdminAccountResponse
  where
  rnf :: DisableIpamOrganizationAdminAccountResponse -> ()
rnf DisableIpamOrganizationAdminAccountResponse' {Int
Maybe Bool
httpStatus :: Int
success :: Maybe Bool
$sel:httpStatus:DisableIpamOrganizationAdminAccountResponse' :: DisableIpamOrganizationAdminAccountResponse -> Int
$sel:success:DisableIpamOrganizationAdminAccountResponse' :: DisableIpamOrganizationAdminAccountResponse -> 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