{-# 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.Organizations.LeaveOrganization
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Removes a member account from its parent organization. This version of
-- the operation is performed by the account that wants to leave. To remove
-- a member account as a user in the management account, use
-- RemoveAccountFromOrganization instead.
--
-- This operation can be called only from a member account in the
-- organization.
--
-- -   The management account in an organization with all features enabled
--     can set service control policies (SCPs) that can restrict what
--     administrators of member accounts can do. This includes preventing
--     them from successfully calling @LeaveOrganization@ and leaving the
--     organization.
--
-- -   You can leave an organization as a member account only if the
--     account is configured with the information required to operate as a
--     standalone account. When you create an account in an organization
--     using the AWS Organizations console, API, or CLI commands, the
--     information required of standalone accounts is /not/ automatically
--     collected. For each account that you want to make standalone, you
--     must perform the following steps. If any of the steps are already
--     completed for this account, that step doesn\'t appear.
--
--     -   Choose a support plan
--
--     -   Provide and verify the required contact information
--
--     -   Provide a current payment method
--
--     AWS uses the payment method to charge for any billable (not free
--     tier) AWS activity that occurs while the account isn\'t attached to
--     an organization. Follow the steps at
--     <http://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_remove.html#leave-without-all-info To leave an organization when all required account information has not yet been provided>
--     in the /AWS Organizations User Guide./
--
-- -   The account that you want to leave must not be a delegated
--     administrator account for any AWS service enabled for your
--     organization. If the account is a delegated administrator, you must
--     first change the delegated administrator account to another account
--     that is remaining in the organization.
--
-- -   You can leave an organization only after you enable IAM user access
--     to billing in your account. For more information, see
--     <http://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/grantaccess.html#ControllingAccessWebsite-Activate Activating Access to the Billing and Cost Management Console>
--     in the /AWS Billing and Cost Management User Guide./
--
-- -   After the account leaves the organization, all tags that were
--     attached to the account object in the organization are deleted. AWS
--     accounts outside of an organization do not support tags.
--
-- -   A newly created account has a waiting period before it can be
--     removed from its organization. If you get an error that indicates
--     that a wait period is required, then try again in a few days.
module Amazonka.Organizations.LeaveOrganization
  ( -- * Creating a Request
    LeaveOrganization (..),
    newLeaveOrganization,

    -- * Destructuring the Response
    LeaveOrganizationResponse (..),
    newLeaveOrganizationResponse,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.Organizations.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

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

-- |
-- Create a value of 'LeaveOrganization' 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.
newLeaveOrganization ::
  LeaveOrganization
newLeaveOrganization :: LeaveOrganization
newLeaveOrganization = LeaveOrganization
LeaveOrganization'

instance Core.AWSRequest LeaveOrganization where
  type
    AWSResponse LeaveOrganization =
      LeaveOrganizationResponse
  request :: LeaveOrganization -> Request LeaveOrganization
request = Service -> LeaveOrganization -> Request LeaveOrganization
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy LeaveOrganization
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse LeaveOrganization)))
response =
    AWSResponse LeaveOrganization
-> Logger
-> Service
-> Proxy LeaveOrganization
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse LeaveOrganization)))
forall (m :: * -> *) a.
MonadResource m =>
AWSResponse a
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveNull AWSResponse LeaveOrganization
LeaveOrganizationResponse
LeaveOrganizationResponse'

instance Prelude.Hashable LeaveOrganization

instance Prelude.NFData LeaveOrganization

instance Core.ToHeaders LeaveOrganization where
  toHeaders :: LeaveOrganization -> [Header]
toHeaders =
    [Header] -> LeaveOrganization -> [Header]
forall a b. a -> b -> a
Prelude.const
      ( [[Header]] -> [Header]
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> [Header]
forall a. ToHeader a => HeaderName -> a -> [Header]
Core.=# ( ByteString
"AWSOrganizationsV20161128.LeaveOrganization" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> [Header]
forall a. ToHeader a => HeaderName -> a -> [Header]
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON LeaveOrganization where
  toJSON :: LeaveOrganization -> Value
toJSON = Value -> LeaveOrganization -> Value
forall a b. a -> b -> a
Prelude.const (Object -> Value
Core.Object Object
forall a. Monoid a => a
Prelude.mempty)

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

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

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

-- |
-- Create a value of 'LeaveOrganizationResponse' 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.
newLeaveOrganizationResponse ::
  LeaveOrganizationResponse
newLeaveOrganizationResponse :: LeaveOrganizationResponse
newLeaveOrganizationResponse =
  LeaveOrganizationResponse
LeaveOrganizationResponse'

instance Prelude.NFData LeaveOrganizationResponse