/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Organizations { /** *

Organizations is a web service that enables you to consolidate your multiple * Amazon Web Services accounts into an organization and centrally manage * your accounts and their resources.

This guide provides descriptions of * the Organizations operations. For more information about using this service, see * the Organizations * User Guide.

Support and feedback for Organizations

We * welcome your feedback. Send your comments to feedback-awsorganizations@amazon.com * or post your feedback and questions in the Organizations support * forum. For more information about the Amazon Web Services support forums, * see Forums Help.

* Endpoint to call When using the CLI or the Amazon Web Services SDK

*

For the current release of Organizations, specify the us-east-1 * region for all Amazon Web Services API and CLI calls made from the commercial * Amazon Web Services Regions outside of China. If calling from one of the Amazon * Web Services Regions in China, then specify cn-northwest-1. You can * do this in the CLI by using these parameters and commands:

  • Use * the following parameter with each command to specify both the endpoint and its * region:

    --endpoint-url * https://organizations.us-east-1.amazonaws.com (from commercial Amazon * Web Services Regions outside of China)

    or

    * --endpoint-url * https://organizations.cn-northwest-1.amazonaws.com.cn (from Amazon Web * Services Regions in China)

  • Use the default endpoint, but * configure your default region with this command:

    aws configure set * default.region us-east-1 (from commercial Amazon Web Services Regions * outside of China)

    or

    aws configure set default.region * cn-northwest-1 (from Amazon Web Services Regions in China)

    *

  • Use the following parameter with each command to specify the * endpoint:

    --region us-east-1 (from commercial Amazon Web * Services Regions outside of China)

    or

    --region * cn-northwest-1 (from Amazon Web Services Regions in China)

    *

Recording API Requests

Organizations supports * CloudTrail, a service that records Amazon Web Services API calls for your Amazon * Web Services account and delivers log files to an Amazon S3 bucket. By using * information collected by CloudTrail, you can determine which requests the * Organizations service received, who made the request and when, and so on. For * more about Organizations and its support for CloudTrail, see Logging * Organizations Events with CloudTrail in the Organizations User Guide. * To learn more about CloudTrail, including how to turn it on and find your log * files, see the CloudTrail * User Guide.

*/ class AWS_ORGANIZATIONS_API OrganizationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef OrganizationsClientConfiguration ClientConfigurationType; typedef OrganizationsEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OrganizationsClient(const Aws::Organizations::OrganizationsClientConfiguration& clientConfiguration = Aws::Organizations::OrganizationsClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OrganizationsClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Organizations::OrganizationsClientConfiguration& clientConfiguration = Aws::Organizations::OrganizationsClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ OrganizationsClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Organizations::OrganizationsClientConfiguration& clientConfiguration = Aws::Organizations::OrganizationsClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OrganizationsClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ OrganizationsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ OrganizationsClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~OrganizationsClient(); /** *

Sends a response to the originator of a handshake agreeing to the action * proposed by the handshake request.

You can only call this operation by * the following principals when they also have the relevant IAM permissions:

*

  • Invitation to join or Approve all features request * handshakes: only a principal from the member account.

    The user who calls * the API for an invitation to join must have the * organizations:AcceptHandshake permission. If you enabled all * features in the organization, the user must also have the * iam:CreateServiceLinkedRole permission so that Organizations can * create the required service-linked role named * AWSServiceRoleForOrganizations. For more information, see Organizations * and Service-Linked Roles in the Organizations User Guide.

    • *

  • Enable all features final confirmation handshake: only a * principal from the management account.

    For more information about * invitations, see Inviting * an Amazon Web Services account to join your organization in the * Organizations User Guide. For more information about requests to enable * all features in the organization, see Enabling * all features in your organization in the Organizations User Guide. *

After you accept a handshake, it continues to appear in the * results of relevant APIs for only 30 days. After that, it's * deleted.

See Also:

AWS * API Reference

*/ virtual Model::AcceptHandshakeOutcome AcceptHandshake(const Model::AcceptHandshakeRequest& request) const; /** * A Callable wrapper for AcceptHandshake that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptHandshakeOutcomeCallable AcceptHandshakeCallable(const AcceptHandshakeRequestT& request) const { return SubmitCallable(&OrganizationsClient::AcceptHandshake, request); } /** * An Async wrapper for AcceptHandshake that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptHandshakeAsync(const AcceptHandshakeRequestT& request, const AcceptHandshakeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::AcceptHandshake, request, handler, context); } /** *

Attaches a policy to a root, an organizational unit (OU), or an individual * account. How the policy affects accounts depends on the type of policy. Refer to * the Organizations User Guide for information about each policy type:

*

This operation can be called only from the organization's * management account.

See Also:

AWS * API Reference

*/ virtual Model::AttachPolicyOutcome AttachPolicy(const Model::AttachPolicyRequest& request) const; /** * A Callable wrapper for AttachPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AttachPolicyOutcomeCallable AttachPolicyCallable(const AttachPolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::AttachPolicy, request); } /** * An Async wrapper for AttachPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AttachPolicyAsync(const AttachPolicyRequestT& request, const AttachPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::AttachPolicy, request, handler, context); } /** *

Cancels a handshake. Canceling a handshake sets the handshake state to * CANCELED.

This operation can be called only from the account * that originated the handshake. The recipient of the handshake can't cancel it, * but can use DeclineHandshake instead. After a handshake is canceled, the * recipient can no longer respond to that handshake.

After you cancel a * handshake, it continues to appear in the results of relevant APIs for only 30 * days. After that, it's deleted.

See Also:

AWS * API Reference

*/ virtual Model::CancelHandshakeOutcome CancelHandshake(const Model::CancelHandshakeRequest& request) const; /** * A Callable wrapper for CancelHandshake that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelHandshakeOutcomeCallable CancelHandshakeCallable(const CancelHandshakeRequestT& request) const { return SubmitCallable(&OrganizationsClient::CancelHandshake, request); } /** * An Async wrapper for CancelHandshake that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelHandshakeAsync(const CancelHandshakeRequestT& request, const CancelHandshakeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::CancelHandshake, request, handler, context); } /** *

Closes an Amazon Web Services member account within an organization. You can * close an account when all * features are enabled . You can't close the management account with this API. * This is an asynchronous request that Amazon Web Services performs in the * background. Because CloseAccount operates asynchronously, it can * return a successful completion message even though account closure might still * be in progress. You need to wait a few minutes before the account is fully * closed. To check the status of the request, do one of the following:

    *

  • Use the AccountId that you sent in the * CloseAccount request to provide as a parameter to the * DescribeAccount operation.

    While the close account request is in * progress, Account status will indicate PENDING_CLOSURE. When the close account * request completes, the status will change to SUSPENDED.

  • Check * the CloudTrail log for the CloseAccountResult event that gets * published after the account closes successfully. For information on using * CloudTrail with Organizations, see Logging * and monitoring in Organizations in the Organizations User Guide.

    *

  • You can close only 10% of member accounts, * between 10 and 200, within a rolling 30 day period. This quota is not bound by a * calendar month, but starts when you close an account.

    After you reach * this limit, you can close additional accounts in the Billing console. For more * information, see Closing * an account in the Amazon Web Services Billing and Cost Management User * Guide.

  • To reinstate a closed account, contact Amazon Web * Services Support within the 90-day grace period while the account is in * SUSPENDED status.

  • If the Amazon Web Services account you * attempt to close is linked to an Amazon Web Services GovCloud (US) account, the * CloseAccount request will close both accounts. To learn important * pre-closure details, see * Closing an Amazon Web Services GovCloud (US) account in the Amazon Web * Services GovCloud User Guide.

For more * information about closing accounts, see Closing * an Amazon Web Services account in the Organizations User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::CloseAccountOutcome CloseAccount(const Model::CloseAccountRequest& request) const; /** * A Callable wrapper for CloseAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CloseAccountOutcomeCallable CloseAccountCallable(const CloseAccountRequestT& request) const { return SubmitCallable(&OrganizationsClient::CloseAccount, request); } /** * An Async wrapper for CloseAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CloseAccountAsync(const CloseAccountRequestT& request, const CloseAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::CloseAccount, request, handler, context); } /** *

Creates an Amazon Web Services account that is automatically a member of the * organization whose credentials made the request. This is an asynchronous request * that Amazon Web Services performs in the background. Because * CreateAccount operates asynchronously, it can return a successful * completion message even though account initialization might still be in * progress. You might need to wait a few minutes before you can successfully * access the account. To check the status of the request, do one of the * following:

  • Use the Id value of the * CreateAccountStatus response element from this operation to provide * as a parameter to the DescribeCreateAccountStatus operation.

    • *

  • Check the CloudTrail log for the CreateAccountResult event. * For information on using CloudTrail with Organizations, see Logging * and monitoring in Organizations in the Organizations User Guide.

    *

The user who calls the API to create an account must have the * organizations:CreateAccount permission. If you enabled all features * in the organization, Organizations creates the required service-linked role * named AWSServiceRoleForOrganizations. For more information, see Organizations * and Service-Linked Roles in the Organizations User Guide.

If * the request includes tags, then the requester must have the * organizations:TagResource permission.

Organizations * preconfigures the new member account with a role (named * OrganizationAccountAccessRole by default) that grants users in the * management account administrator permissions in the new member account. * Principals in the management account can assume the role. Organizations clones * the company name and address information for the new account from the * organization's management account.

This operation can be called only from * the organization's management account.

For more information about * creating accounts, see Creating * an Amazon Web Services account in Your Organization in the Organizations * User Guide.

  • When you create an account in an * organization using the Organizations console, API, or CLI commands, the * information required for the account to operate as a standalone account, such as * a payment method and signing the end user license agreement (EULA) is not * automatically collected. If you must remove an account from your organization * later, you can do so only after you provide the missing information. Follow the * steps at * To leave an organization as a member account in the Organizations User * Guide.

  • If you get an exception that indicates that you * exceeded your account limits for the organization, contact Amazon Web Services * Support.

  • If you get an exception that indicates that the * operation failed because your organization is still initializing, wait one hour * and then try again. If the error persists, contact Amazon Web Services * Support.

  • Using CreateAccount to create * multiple temporary accounts isn't recommended. You can only close an account * from the Billing and Cost Management console, and you must be signed in as the * root user. For information on the requirements and process for closing an * account, see Closing * an Amazon Web Services account in the Organizations User Guide.

    *

When you create a member account with this * operation, you can choose whether to create the account with the IAM User and * Role Access to Billing Information switch enabled. If you enable it, IAM * users and roles that have appropriate permissions can view billing information * for the account. If you disable it, only the account root user can access * billing information. For information about how to disable this switch for an * account, see Granting * Access to Your Billing Information and Tools.

See * Also:

AWS * API Reference

*/ virtual Model::CreateAccountOutcome CreateAccount(const Model::CreateAccountRequest& request) const; /** * A Callable wrapper for CreateAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAccountOutcomeCallable CreateAccountCallable(const CreateAccountRequestT& request) const { return SubmitCallable(&OrganizationsClient::CreateAccount, request); } /** * An Async wrapper for CreateAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAccountAsync(const CreateAccountRequestT& request, const CreateAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::CreateAccount, request, handler, context); } /** *

This action is available if all of the following are true:

  • *

    You're authorized to create accounts in the Amazon Web Services GovCloud (US) * Region. For more information on the Amazon Web Services GovCloud (US) Region, * see the * Amazon Web Services GovCloud User Guide.

  • You * already have an account in the Amazon Web Services GovCloud (US) Region that is * paired with a management account of an organization in the commercial * Region.

  • You call this action from the management account of * your organization in the commercial Region.

  • You have the * organizations:CreateGovCloudAccount permission.

*

Organizations automatically creates the required service-linked role named * AWSServiceRoleForOrganizations. For more information, see Organizations * and Service-Linked Roles in the Organizations User Guide.

*

Amazon Web Services automatically enables CloudTrail for Amazon Web Services * GovCloud (US) accounts, but you should also do the following:

  • *

    Verify that CloudTrail is enabled to store logs.

  • Create an * Amazon S3 bucket for CloudTrail log storage.

    For more information, see Verifying * CloudTrail Is Enabled in the Amazon Web Services GovCloud User Guide. *

If the request includes tags, then the requester must have * the organizations:TagResource permission. The tags are attached to * the commercial account associated with the GovCloud account, rather than the * GovCloud account itself. To add tags to the GovCloud account, call the * TagResource operation in the GovCloud Region after the new GovCloud * account exists.

You call this action from the management account of your * organization in the commercial Region to create a standalone Amazon Web Services * account in the Amazon Web Services GovCloud (US) Region. After the account is * created, the management account of an organization in the Amazon Web Services * GovCloud (US) Region can invite it to that organization. For more information on * inviting standalone accounts in the Amazon Web Services GovCloud (US) to join an * organization, see Organizations * in the Amazon Web Services GovCloud User Guide.

Calling * CreateGovCloudAccount is an asynchronous request that Amazon Web * Services performs in the background. Because CreateGovCloudAccount * operates asynchronously, it can return a successful completion message even * though account initialization might still be in progress. You might need to wait * a few minutes before you can successfully access the account. To check the * status of the request, do one of the following:

When you call the CreateGovCloudAccount * action, you create two accounts: a standalone account in the Amazon Web Services * GovCloud (US) Region and an associated account in the commercial Region for * billing and support purposes. The account in the commercial Region is * automatically a member of the organization whose credentials made the request. * Both accounts are associated with the same email address.

A role is * created in the new account in the commercial Region that allows the management * account in the organization in the commercial Region to assume it. An Amazon Web * Services GovCloud (US) account is then created and associated with the * commercial account that you just created. A role is also created in the new * Amazon Web Services GovCloud (US) account that can be assumed by the Amazon Web * Services GovCloud (US) account that is associated with the management account of * the commercial organization. For more information and to view a diagram that * explains how account access works, see Organizations * in the Amazon Web Services GovCloud User Guide.

For more * information about creating accounts, see Creating * an Amazon Web Services account in Your Organization in the Organizations * User Guide.

  • When you create an account in an * organization using the Organizations console, API, or CLI commands, the * information required for the account to operate as a standalone account is * not automatically collected. This includes a payment method and signing * the end user license agreement (EULA). If you must remove an account from your * organization later, you can do so only after you provide the missing * information. Follow the steps at * To leave an organization as a member account in the Organizations User * Guide.

  • If you get an exception that indicates that you * exceeded your account limits for the organization, contact Amazon Web Services * Support.

  • If you get an exception that indicates that the * operation failed because your organization is still initializing, wait one hour * and then try again. If the error persists, contact Amazon Web Services * Support.

  • Using CreateGovCloudAccount to * create multiple temporary accounts isn't recommended. You can only close an * account from the Amazon Web Services Billing and Cost Management console, and * you must be signed in as the root user. For information on the requirements and * process for closing an account, see Closing * an Amazon Web Services account in the Organizations User Guide.

    *

When you create a member account with this * operation, you can choose whether to create the account with the IAM User and * Role Access to Billing Information switch enabled. If you enable it, IAM * users and roles that have appropriate permissions can view billing information * for the account. If you disable it, only the account root user can access * billing information. For information about how to disable this switch for an * account, see Granting * Access to Your Billing Information and Tools.

See * Also:

AWS * API Reference

*/ virtual Model::CreateGovCloudAccountOutcome CreateGovCloudAccount(const Model::CreateGovCloudAccountRequest& request) const; /** * A Callable wrapper for CreateGovCloudAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGovCloudAccountOutcomeCallable CreateGovCloudAccountCallable(const CreateGovCloudAccountRequestT& request) const { return SubmitCallable(&OrganizationsClient::CreateGovCloudAccount, request); } /** * An Async wrapper for CreateGovCloudAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGovCloudAccountAsync(const CreateGovCloudAccountRequestT& request, const CreateGovCloudAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::CreateGovCloudAccount, request, handler, context); } /** *

Creates an Amazon Web Services organization. The account whose user is * calling the CreateOrganization operation automatically becomes the * management * account of the new organization.

This operation must be called using * credentials from the account that is to become the new organization's management * account. The principal must also have the relevant IAM permissions.

By * default (or if you set the FeatureSet parameter to * ALL), the new organization is created with all features enabled and * service control policies automatically enabled in the root. If you instead * choose to create the organization supporting only the consolidated billing * features by setting the FeatureSet parameter to * CONSOLIDATED_BILLING", no policy types are enabled by default, and * you can't use organization policies

See Also:

AWS * API Reference

*/ virtual Model::CreateOrganizationOutcome CreateOrganization(const Model::CreateOrganizationRequest& request) const; /** * A Callable wrapper for CreateOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOrganizationOutcomeCallable CreateOrganizationCallable(const CreateOrganizationRequestT& request) const { return SubmitCallable(&OrganizationsClient::CreateOrganization, request); } /** * An Async wrapper for CreateOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOrganizationAsync(const CreateOrganizationRequestT& request, const CreateOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::CreateOrganization, request, handler, context); } /** *

Creates an organizational unit (OU) within a root or parent OU. An OU is a * container for accounts that enables you to organize your accounts to apply * policies according to your business requirements. The number of levels deep that * you can nest OUs is dependent upon the policy types enabled for that root. For * service control policies, the limit is five.

For more information about * OUs, see Managing * Organizational Units in the Organizations User Guide.

If the * request includes tags, then the requester must have the * organizations:TagResource permission.

This operation can be * called only from the organization's management account.

See Also:

* AWS * API Reference

*/ virtual Model::CreateOrganizationalUnitOutcome CreateOrganizationalUnit(const Model::CreateOrganizationalUnitRequest& request) const; /** * A Callable wrapper for CreateOrganizationalUnit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOrganizationalUnitOutcomeCallable CreateOrganizationalUnitCallable(const CreateOrganizationalUnitRequestT& request) const { return SubmitCallable(&OrganizationsClient::CreateOrganizationalUnit, request); } /** * An Async wrapper for CreateOrganizationalUnit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOrganizationalUnitAsync(const CreateOrganizationalUnitRequestT& request, const CreateOrganizationalUnitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::CreateOrganizationalUnit, request, handler, context); } /** *

Creates a policy of a specified type that you can attach to a root, an * organizational unit (OU), or an individual Amazon Web Services account.

*

For more information about policies and their use, see Managing * Organization Policies.

If the request includes tags, then the * requester must have the organizations:TagResource permission.

*

This operation can be called only from the organization's management * account.

See Also:

AWS * API Reference

*/ virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const; /** * A Callable wrapper for CreatePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::CreatePolicy, request); } /** * An Async wrapper for CreatePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePolicyAsync(const CreatePolicyRequestT& request, const CreatePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::CreatePolicy, request, handler, context); } /** *

Declines a handshake request. This sets the handshake state to * DECLINED and effectively deactivates the request.

This * operation can be called only from the account that received the handshake. The * originator of the handshake can use CancelHandshake instead. The * originator can't reactivate a declined request, but can reinitiate the process * with a new handshake request.

After you decline a handshake, it continues * to appear in the results of relevant APIs for only 30 days. After that, it's * deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeclineHandshakeOutcome DeclineHandshake(const Model::DeclineHandshakeRequest& request) const; /** * A Callable wrapper for DeclineHandshake that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeclineHandshakeOutcomeCallable DeclineHandshakeCallable(const DeclineHandshakeRequestT& request) const { return SubmitCallable(&OrganizationsClient::DeclineHandshake, request); } /** * An Async wrapper for DeclineHandshake that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeclineHandshakeAsync(const DeclineHandshakeRequestT& request, const DeclineHandshakeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DeclineHandshake, request, handler, context); } /** *

Deletes the organization. You can delete an organization only by using * credentials from the management account. The organization must be empty of * member accounts.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOrganizationOutcome DeleteOrganization() const; /** * A Callable wrapper for DeleteOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOrganizationOutcomeCallable DeleteOrganizationCallable() const { return SubmitCallable(&OrganizationsClient::DeleteOrganization); } /** * An Async wrapper for DeleteOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOrganizationAsync(const DeleteOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DeleteOrganization, handler, context); } /** *

Deletes an organizational unit (OU) from a root or another OU. You must first * remove all accounts and child OUs from the OU that you want to delete.

*

This operation can be called only from the organization's management * account.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOrganizationalUnitOutcome DeleteOrganizationalUnit(const Model::DeleteOrganizationalUnitRequest& request) const; /** * A Callable wrapper for DeleteOrganizationalUnit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOrganizationalUnitOutcomeCallable DeleteOrganizationalUnitCallable(const DeleteOrganizationalUnitRequestT& request) const { return SubmitCallable(&OrganizationsClient::DeleteOrganizationalUnit, request); } /** * An Async wrapper for DeleteOrganizationalUnit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOrganizationalUnitAsync(const DeleteOrganizationalUnitRequestT& request, const DeleteOrganizationalUnitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DeleteOrganizationalUnit, request, handler, context); } /** *

Deletes the specified policy from your organization. Before you perform this * operation, you must first detach the policy from all organizational units (OUs), * roots, and accounts.

This operation can be called only from the * organization's management account.

See Also:

AWS * API Reference

*/ virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const; /** * A Callable wrapper for DeletePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::DeletePolicy, request); } /** * An Async wrapper for DeletePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DeletePolicy, request, handler, context); } /** *

Deletes the resource policy from your organization.

You can only call * this operation from the organization's management account.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy() const; /** * A Callable wrapper for DeleteResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable() const { return SubmitCallable(&OrganizationsClient::DeleteResourcePolicy); } /** * An Async wrapper for DeleteResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResourcePolicyAsync(const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DeleteResourcePolicy, handler, context); } /** *

Removes the specified member Amazon Web Services account as a delegated * administrator for the specified Amazon Web Services service.

*

Deregistering a delegated administrator can have unintended impacts on the * functionality of the enabled Amazon Web Services service. See the documentation * for the enabled service before you deregister a delegated administrator so that * you understand any potential impacts.

You can run this * action only for Amazon Web Services services that support this feature. For a * current list of services that support it, see the column Supports Delegated * Administrator in the table at Amazon * Web Services Services that you can use with Organizations in the * Organizations User Guide.

This operation can be called only from * the organization's management account.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterDelegatedAdministratorOutcome DeregisterDelegatedAdministrator(const Model::DeregisterDelegatedAdministratorRequest& request) const; /** * A Callable wrapper for DeregisterDelegatedAdministrator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterDelegatedAdministratorOutcomeCallable DeregisterDelegatedAdministratorCallable(const DeregisterDelegatedAdministratorRequestT& request) const { return SubmitCallable(&OrganizationsClient::DeregisterDelegatedAdministrator, request); } /** * An Async wrapper for DeregisterDelegatedAdministrator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterDelegatedAdministratorAsync(const DeregisterDelegatedAdministratorRequestT& request, const DeregisterDelegatedAdministratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DeregisterDelegatedAdministrator, request, handler, context); } /** *

Retrieves Organizations-related information about the specified account.

*

This operation can be called only from the organization's management account * or by a member account that is a delegated administrator for an Amazon Web * Services service.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountOutcome DescribeAccount(const Model::DescribeAccountRequest& request) const; /** * A Callable wrapper for DescribeAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountOutcomeCallable DescribeAccountCallable(const DescribeAccountRequestT& request) const { return SubmitCallable(&OrganizationsClient::DescribeAccount, request); } /** * An Async wrapper for DescribeAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountAsync(const DescribeAccountRequestT& request, const DescribeAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribeAccount, request, handler, context); } /** *

Retrieves the current status of an asynchronous request to create an * account.

This operation can be called only from the organization's * management account or by a member account that is a delegated administrator for * an Amazon Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCreateAccountStatusOutcome DescribeCreateAccountStatus(const Model::DescribeCreateAccountStatusRequest& request) const; /** * A Callable wrapper for DescribeCreateAccountStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCreateAccountStatusOutcomeCallable DescribeCreateAccountStatusCallable(const DescribeCreateAccountStatusRequestT& request) const { return SubmitCallable(&OrganizationsClient::DescribeCreateAccountStatus, request); } /** * An Async wrapper for DescribeCreateAccountStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCreateAccountStatusAsync(const DescribeCreateAccountStatusRequestT& request, const DescribeCreateAccountStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribeCreateAccountStatus, request, handler, context); } /** *

Returns the contents of the effective policy for specified policy type and * account. The effective policy is the aggregation of any policies of the * specified type that the account inherits, plus any policy of that type that is * directly attached to the account.

This operation applies only to policy * types other than service control policies (SCPs).

For more * information about policy inheritance, see How * Policy Inheritance Works in the Organizations User Guide.

This * operation can be called only from the organization's management account or by a * member account that is a delegated administrator for an Amazon Web Services * service.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEffectivePolicyOutcome DescribeEffectivePolicy(const Model::DescribeEffectivePolicyRequest& request) const; /** * A Callable wrapper for DescribeEffectivePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEffectivePolicyOutcomeCallable DescribeEffectivePolicyCallable(const DescribeEffectivePolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::DescribeEffectivePolicy, request); } /** * An Async wrapper for DescribeEffectivePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEffectivePolicyAsync(const DescribeEffectivePolicyRequestT& request, const DescribeEffectivePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribeEffectivePolicy, request, handler, context); } /** *

Retrieves information about a previously requested handshake. The handshake * ID comes from the response to the original InviteAccountToOrganization * operation that generated the handshake.

You can access handshakes that * are ACCEPTED, DECLINED, or CANCELED for * only 30 days after they change to that state. They're then deleted and no longer * accessible.

This operation can be called from any account in the * organization.

See Also:

AWS * API Reference

*/ virtual Model::DescribeHandshakeOutcome DescribeHandshake(const Model::DescribeHandshakeRequest& request) const; /** * A Callable wrapper for DescribeHandshake that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeHandshakeOutcomeCallable DescribeHandshakeCallable(const DescribeHandshakeRequestT& request) const { return SubmitCallable(&OrganizationsClient::DescribeHandshake, request); } /** * An Async wrapper for DescribeHandshake that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeHandshakeAsync(const DescribeHandshakeRequestT& request, const DescribeHandshakeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribeHandshake, request, handler, context); } /** *

Retrieves information about the organization that the user's account belongs * to.

This operation can be called from any account in the * organization.

Even if a policy type is shown as available in the * organization, you can disable it separately at the root level with * DisablePolicyType. Use ListRoots to see the status of policy types * for a specified root.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationOutcome DescribeOrganization() const; /** * A Callable wrapper for DescribeOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationOutcomeCallable DescribeOrganizationCallable() const { return SubmitCallable(&OrganizationsClient::DescribeOrganization); } /** * An Async wrapper for DescribeOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationAsync(const DescribeOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribeOrganization, handler, context); } /** *

Retrieves information about an organizational unit (OU).

This * operation can be called only from the organization's management account or by a * member account that is a delegated administrator for an Amazon Web Services * service.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrganizationalUnitOutcome DescribeOrganizationalUnit(const Model::DescribeOrganizationalUnitRequest& request) const; /** * A Callable wrapper for DescribeOrganizationalUnit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrganizationalUnitOutcomeCallable DescribeOrganizationalUnitCallable(const DescribeOrganizationalUnitRequestT& request) const { return SubmitCallable(&OrganizationsClient::DescribeOrganizationalUnit, request); } /** * An Async wrapper for DescribeOrganizationalUnit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrganizationalUnitAsync(const DescribeOrganizationalUnitRequestT& request, const DescribeOrganizationalUnitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribeOrganizationalUnit, request, handler, context); } /** *

Retrieves information about a policy.

This operation can be called * only from the organization's management account or by a member account that is a * delegated administrator for an Amazon Web Services service.

See * Also:

AWS * API Reference

*/ virtual Model::DescribePolicyOutcome DescribePolicy(const Model::DescribePolicyRequest& request) const; /** * A Callable wrapper for DescribePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePolicyOutcomeCallable DescribePolicyCallable(const DescribePolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::DescribePolicy, request); } /** * An Async wrapper for DescribePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePolicyAsync(const DescribePolicyRequestT& request, const DescribePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribePolicy, request, handler, context); } /** *

Retrieves information about a resource policy.

You can only call this * operation from the organization's management account or by a member account that * is a delegated administrator for an Amazon Web Services service.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy() const; /** * A Callable wrapper for DescribeResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable() const { return SubmitCallable(&OrganizationsClient::DescribeResourcePolicy); } /** * An Async wrapper for DescribeResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeResourcePolicyAsync(const DescribeResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DescribeResourcePolicy, handler, context); } /** *

Detaches a policy from a target root, organizational unit (OU), or * account.

If the policy being detached is a service control * policy (SCP), the changes to permissions for Identity and Access Management * (IAM) users and roles in affected accounts are immediate.

*

Every root, OU, and account must have at least one SCP attached. If you want * to replace the default FullAWSAccess policy with an SCP that limits * the permissions that can be delegated, you must attach the replacement SCP * before you can remove the default SCP. This is the authorization strategy of an * "allow * list". If you instead attach a second SCP and leave the * FullAWSAccess SCP still attached, and specify "Effect": * "Deny" in the second SCP to override the "Effect": "Allow" * in the FullAWSAccess policy (or any other attached SCP), you're * using the authorization strategy of a "deny * list".

This operation can be called only from the organization's * management account.

See Also:

AWS * API Reference

*/ virtual Model::DetachPolicyOutcome DetachPolicy(const Model::DetachPolicyRequest& request) const; /** * A Callable wrapper for DetachPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DetachPolicyOutcomeCallable DetachPolicyCallable(const DetachPolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::DetachPolicy, request); } /** * An Async wrapper for DetachPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DetachPolicyAsync(const DetachPolicyRequestT& request, const DetachPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DetachPolicy, request, handler, context); } /** *

Disables the integration of an Amazon Web Services service (the service that * is specified by ServicePrincipal) with Organizations. When you * disable integration, the specified service no longer can create a service-linked * role in new accounts in your organization. This means the service * can't perform operations on your behalf on any new accounts in your * organization. The service can still perform operations in older accounts until * the service completes its clean-up from Organizations.

We * strongly recommend that you don't use this command to disable * integration between Organizations and the specified Amazon Web Services service. * Instead, use the console or commands that are provided by the specified service. * This lets the trusted service perform any required initialization when enabling * trusted access, such as creating any required resources and any required clean * up of resources when disabling trusted access.

For information about how * to disable trusted service access to your organization using the trusted * service, see the Learn more link under the Supports Trusted Access * column at Amazon * Web Services services that you can use with Organizations. on this page.

*

If you disable access by using this command, it causes the following actions * to occur:

  • The service can no longer create a service-linked * role in the accounts in your organization. This means that the service can't * perform operations on your behalf on any new accounts in your organization. The * service can still perform operations in older accounts until the service * completes its clean-up from Organizations.

  • The service can no * longer perform tasks in the member accounts in the organization, unless those * operations are explicitly permitted by the IAM policies that are attached to * your roles. This includes any data aggregation from the member accounts to the * management account, or to a delegated administrator account, where relevant.

    *

  • Some services detect this and clean up any remaining data or * resources related to the integration, while other services stop accessing the * organization but leave any historical data and configuration in place to support * a possible re-enabling of the integration.

Using the other * service's console or commands to disable the integration ensures that the other * service is aware that it can clean up any resources that are required only for * the integration. How the service cleans up its resources in the organization's * accounts depends on that service. For more information, see the documentation * for the other Amazon Web Services service.

After you * perform the DisableAWSServiceAccess operation, the specified * service can no longer perform operations in your organization's accounts

*

For more information about integrating other services with Organizations, * including the list of services that work with Organizations, see Integrating * Organizations with Other Amazon Web Services Services in the * Organizations User Guide.

This operation can be called only from * the organization's management account.

See Also:

AWS * API Reference

*/ virtual Model::DisableAWSServiceAccessOutcome DisableAWSServiceAccess(const Model::DisableAWSServiceAccessRequest& request) const; /** * A Callable wrapper for DisableAWSServiceAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableAWSServiceAccessOutcomeCallable DisableAWSServiceAccessCallable(const DisableAWSServiceAccessRequestT& request) const { return SubmitCallable(&OrganizationsClient::DisableAWSServiceAccess, request); } /** * An Async wrapper for DisableAWSServiceAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableAWSServiceAccessAsync(const DisableAWSServiceAccessRequestT& request, const DisableAWSServiceAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DisableAWSServiceAccess, request, handler, context); } /** *

Disables an organizational policy type in a root. A policy of a certain type * can be attached to entities in a root only if that type is enabled in the root. * After you perform this operation, you no longer can attach policies of the * specified type to that root or to any organizational unit (OU) or account in * that root. You can undo this by using the EnablePolicyType operation.

*

This is an asynchronous request that Amazon Web Services performs in the * background. If you disable a policy type for a root, it still appears enabled * for the organization if all * features are enabled for the organization. Amazon Web Services recommends * that you first use ListRoots to see the status of policy types for a * specified root, and then use this operation.

This operation can be called * only from the organization's management account.

To view the status of * available policy types in the organization, use * DescribeOrganization.

See Also:

AWS * API Reference

*/ virtual Model::DisablePolicyTypeOutcome DisablePolicyType(const Model::DisablePolicyTypeRequest& request) const; /** * A Callable wrapper for DisablePolicyType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisablePolicyTypeOutcomeCallable DisablePolicyTypeCallable(const DisablePolicyTypeRequestT& request) const { return SubmitCallable(&OrganizationsClient::DisablePolicyType, request); } /** * An Async wrapper for DisablePolicyType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisablePolicyTypeAsync(const DisablePolicyTypeRequestT& request, const DisablePolicyTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::DisablePolicyType, request, handler, context); } /** *

Enables the integration of an Amazon Web Services service (the service that * is specified by ServicePrincipal) with Organizations. When you * enable integration, you allow the specified service to create a service-linked * role in all the accounts in your organization. This allows the service to * perform operations on your behalf in your organization and its accounts.

*

We recommend that you enable integration between Organizations * and the specified Amazon Web Services service by using the console or commands * that are provided by the specified service. Doing so ensures that the service is * aware that it can create the resources that are required for the integration. * How the service creates those resources in the organization's accounts depends * on that service. For more information, see the documentation for the other * Amazon Web Services service.

For more information about * enabling services to integrate with Organizations, see Integrating * Organizations with Other Amazon Web Services Services in the * Organizations User Guide.

You can only call this operation from * the organization's management account and only if the organization has enabled * all features.

See Also:

AWS * API Reference

*/ virtual Model::EnableAWSServiceAccessOutcome EnableAWSServiceAccess(const Model::EnableAWSServiceAccessRequest& request) const; /** * A Callable wrapper for EnableAWSServiceAccess that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableAWSServiceAccessOutcomeCallable EnableAWSServiceAccessCallable(const EnableAWSServiceAccessRequestT& request) const { return SubmitCallable(&OrganizationsClient::EnableAWSServiceAccess, request); } /** * An Async wrapper for EnableAWSServiceAccess that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableAWSServiceAccessAsync(const EnableAWSServiceAccessRequestT& request, const EnableAWSServiceAccessResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::EnableAWSServiceAccess, request, handler, context); } /** *

Enables all features in an organization. This enables the use of organization * policies that can restrict the services and actions that can be called in each * account. Until you enable all features, you have access only to consolidated * billing, and you can't use any of the advanced account administration features * that Organizations supports. For more information, see Enabling * All Features in Your Organization in the Organizations User Guide. *

This operation is required only for organizations that were * created explicitly with only the consolidated billing features enabled. Calling * this operation sends a handshake to every invited account in the organization. * The feature set change can be finalized and the additional features enabled only * after all administrators in the invited accounts approve the change by accepting * the handshake.

After you enable all features, you can * separately enable or disable individual policy types in a root using * EnablePolicyType and DisablePolicyType. To see the status of * policy types in a root, use ListRoots.

After all invited member * accounts accept the handshake, you finalize the feature set change by accepting * the handshake that contains "Action": "ENABLE_ALL_FEATURES". This * completes the change.

After you enable all features in your organization, * the management account in the organization can apply policies on all member * accounts. These policies can restrict what users and even administrators in * those accounts can do. The management account can apply policies that prevent * accounts from leaving the organization. Ensure that your account administrators * are aware of this.

This operation can be called only from the * organization's management account.

See Also:

AWS * API Reference

*/ virtual Model::EnableAllFeaturesOutcome EnableAllFeatures(const Model::EnableAllFeaturesRequest& request) const; /** * A Callable wrapper for EnableAllFeatures that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableAllFeaturesOutcomeCallable EnableAllFeaturesCallable(const EnableAllFeaturesRequestT& request) const { return SubmitCallable(&OrganizationsClient::EnableAllFeatures, request); } /** * An Async wrapper for EnableAllFeatures that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableAllFeaturesAsync(const EnableAllFeaturesRequestT& request, const EnableAllFeaturesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::EnableAllFeatures, request, handler, context); } /** *

Enables a policy type in a root. After you enable a policy type in a root, * you can attach policies of that type to the root, any organizational unit (OU), * or account in that root. You can undo this by using the DisablePolicyType * operation.

This is an asynchronous request that Amazon Web Services * performs in the background. Amazon Web Services recommends that you first use * ListRoots to see the status of policy types for a specified root, and * then use this operation.

This operation can be called only from the * organization's management account.

You can enable a policy type in a root * only if that policy type is available in the organization. To view the status of * available policy types in the organization, use * DescribeOrganization.

See Also:

AWS * API Reference

*/ virtual Model::EnablePolicyTypeOutcome EnablePolicyType(const Model::EnablePolicyTypeRequest& request) const; /** * A Callable wrapper for EnablePolicyType that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnablePolicyTypeOutcomeCallable EnablePolicyTypeCallable(const EnablePolicyTypeRequestT& request) const { return SubmitCallable(&OrganizationsClient::EnablePolicyType, request); } /** * An Async wrapper for EnablePolicyType that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnablePolicyTypeAsync(const EnablePolicyTypeRequestT& request, const EnablePolicyTypeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::EnablePolicyType, request, handler, context); } /** *

Sends an invitation to another account to join your organization as a member * account. Organizations sends email on your behalf to the email address that is * associated with the other account's owner. The invitation is implemented as a * Handshake whose details are in the response.

  • *

    You can invite Amazon Web Services accounts only from the same seller as the * management account. For example, if your organization's management account was * created by Amazon Internet Services Pvt. Ltd (AISPL), an Amazon Web Services * seller in India, you can invite only other AISPL accounts to your organization. * You can't combine accounts from AISPL and Amazon Web Services or from any other * Amazon Web Services seller. For more information, see Consolidated * Billing in India.

  • If you receive an exception that * indicates that you exceeded your account limits for the organization or that the * operation failed because your organization is still initializing, wait one hour * and then try again. If the error persists after an hour, contact Amazon Web Services * Support.

If the request includes tags, then * the requester must have the organizations:TagResource * permission.

This operation can be called only from the organization's * management account.

See Also:

AWS * API Reference

*/ virtual Model::InviteAccountToOrganizationOutcome InviteAccountToOrganization(const Model::InviteAccountToOrganizationRequest& request) const; /** * A Callable wrapper for InviteAccountToOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::InviteAccountToOrganizationOutcomeCallable InviteAccountToOrganizationCallable(const InviteAccountToOrganizationRequestT& request) const { return SubmitCallable(&OrganizationsClient::InviteAccountToOrganization, request); } /** * An Async wrapper for InviteAccountToOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void InviteAccountToOrganizationAsync(const InviteAccountToOrganizationRequestT& request, const InviteAccountToOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::InviteAccountToOrganization, request, handler, context); } /** *

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 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

      • *

    Amazon Web Services uses the payment method to charge for any billable * (not free tier) Amazon Web Services activity that occurs while the account isn't * attached to an organization. Follow the steps at * To leave an organization when all required account information has not yet been * provided in the Organizations User Guide.

  • The * account that you want to leave must not be a delegated administrator account for * any Amazon Web Services 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 Activating * Access to the Billing and Cost Management Console in the Amazon Web * Services 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. Amazon Web Services 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.

See Also:

AWS * API Reference

*/ virtual Model::LeaveOrganizationOutcome LeaveOrganization() const; /** * A Callable wrapper for LeaveOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::LeaveOrganizationOutcomeCallable LeaveOrganizationCallable() const { return SubmitCallable(&OrganizationsClient::LeaveOrganization); } /** * An Async wrapper for LeaveOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void LeaveOrganizationAsync(const LeaveOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::LeaveOrganization, handler, context); } /** *

Returns a list of the Amazon Web Services services that you enabled to * integrate with your organization. After a service on this list creates the * resources that it requires for the integration, it can perform operations on * your organization and its accounts.

For more information about * integrating other services with Organizations, including the list of services * that currently work with Organizations, see Integrating * Organizations with Other Amazon Web Services Services in the * Organizations User Guide.

This operation can be called only from * the organization's management account or by a member account that is a delegated * administrator for an Amazon Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListAWSServiceAccessForOrganizationOutcome ListAWSServiceAccessForOrganization(const Model::ListAWSServiceAccessForOrganizationRequest& request) const; /** * A Callable wrapper for ListAWSServiceAccessForOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAWSServiceAccessForOrganizationOutcomeCallable ListAWSServiceAccessForOrganizationCallable(const ListAWSServiceAccessForOrganizationRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListAWSServiceAccessForOrganization, request); } /** * An Async wrapper for ListAWSServiceAccessForOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAWSServiceAccessForOrganizationAsync(const ListAWSServiceAccessForOrganizationRequestT& request, const ListAWSServiceAccessForOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListAWSServiceAccessForOrganization, request, handler, context); } /** *

Lists all the accounts in the organization. To request only the accounts in a * specified root or organizational unit (OU), use the ListAccountsForParent * operation instead.

Always check the NextToken * response parameter for a null value when calling a * List* operation. These operations can occasionally return an empty * set of results even when there are more results available. The * NextToken response parameter value is null only * when there are no more results to display.

This operation can be * called only from the organization's management account or by a member account * that is a delegated administrator for an Amazon Web Services * service.

See Also:

AWS * API Reference

*/ virtual Model::ListAccountsOutcome ListAccounts(const Model::ListAccountsRequest& request) const; /** * A Callable wrapper for ListAccounts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAccountsOutcomeCallable ListAccountsCallable(const ListAccountsRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListAccounts, request); } /** * An Async wrapper for ListAccounts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAccountsAsync(const ListAccountsRequestT& request, const ListAccountsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListAccounts, request, handler, context); } /** *

Lists the accounts in an organization that are contained by the specified * target root or organizational unit (OU). If you specify the root, you get a list * of all the accounts that aren't in any OU. If you specify an OU, you get a list * of all the accounts in only that OU and not in any child OUs. To get a list of * all accounts in the organization, use the ListAccounts operation.

*

Always check the NextToken response parameter for a * null value when calling a List* operation. These * operations can occasionally return an empty set of results even when there are * more results available. The NextToken response parameter value is * null only when there are no more results to display.

*

This operation can be called only from the organization's management * account or by a member account that is a delegated administrator for an Amazon * Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListAccountsForParentOutcome ListAccountsForParent(const Model::ListAccountsForParentRequest& request) const; /** * A Callable wrapper for ListAccountsForParent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAccountsForParentOutcomeCallable ListAccountsForParentCallable(const ListAccountsForParentRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListAccountsForParent, request); } /** * An Async wrapper for ListAccountsForParent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAccountsForParentAsync(const ListAccountsForParentRequestT& request, const ListAccountsForParentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListAccountsForParent, request, handler, context); } /** *

Lists all of the organizational units (OUs) or accounts that are contained in * the specified parent OU or root. This operation, along with ListParents * enables you to traverse the tree structure that makes up this root.

*

Always check the NextToken response parameter for a * null value when calling a List* operation. These * operations can occasionally return an empty set of results even when there are * more results available. The NextToken response parameter value is * null only when there are no more results to display.

*

This operation can be called only from the organization's management * account or by a member account that is a delegated administrator for an Amazon * Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListChildrenOutcome ListChildren(const Model::ListChildrenRequest& request) const; /** * A Callable wrapper for ListChildren that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListChildrenOutcomeCallable ListChildrenCallable(const ListChildrenRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListChildren, request); } /** * An Async wrapper for ListChildren that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListChildrenAsync(const ListChildrenRequestT& request, const ListChildrenResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListChildren, request, handler, context); } /** *

Lists the account creation requests that match the specified status that is * currently being tracked for the organization.

Always check the * NextToken response parameter for a null value when * calling a List* operation. These operations can occasionally return * an empty set of results even when there are more results available. The * NextToken response parameter value is null only * when there are no more results to display.

This operation can be * called only from the organization's management account or by a member account * that is a delegated administrator for an Amazon Web Services * service.

See Also:

AWS * API Reference

*/ virtual Model::ListCreateAccountStatusOutcome ListCreateAccountStatus(const Model::ListCreateAccountStatusRequest& request) const; /** * A Callable wrapper for ListCreateAccountStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCreateAccountStatusOutcomeCallable ListCreateAccountStatusCallable(const ListCreateAccountStatusRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListCreateAccountStatus, request); } /** * An Async wrapper for ListCreateAccountStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCreateAccountStatusAsync(const ListCreateAccountStatusRequestT& request, const ListCreateAccountStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListCreateAccountStatus, request, handler, context); } /** *

Lists the Amazon Web Services accounts that are designated as delegated * administrators in this organization.

This operation can be called only * from the organization's management account or by a member account that is a * delegated administrator for an Amazon Web Services service.

See * Also:

AWS * API Reference

*/ virtual Model::ListDelegatedAdministratorsOutcome ListDelegatedAdministrators(const Model::ListDelegatedAdministratorsRequest& request) const; /** * A Callable wrapper for ListDelegatedAdministrators that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDelegatedAdministratorsOutcomeCallable ListDelegatedAdministratorsCallable(const ListDelegatedAdministratorsRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListDelegatedAdministrators, request); } /** * An Async wrapper for ListDelegatedAdministrators that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDelegatedAdministratorsAsync(const ListDelegatedAdministratorsRequestT& request, const ListDelegatedAdministratorsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListDelegatedAdministrators, request, handler, context); } /** *

List the Amazon Web Services services for which the specified account is a * delegated administrator.

This operation can be called only from the * organization's management account or by a member account that is a delegated * administrator for an Amazon Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListDelegatedServicesForAccountOutcome ListDelegatedServicesForAccount(const Model::ListDelegatedServicesForAccountRequest& request) const; /** * A Callable wrapper for ListDelegatedServicesForAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDelegatedServicesForAccountOutcomeCallable ListDelegatedServicesForAccountCallable(const ListDelegatedServicesForAccountRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListDelegatedServicesForAccount, request); } /** * An Async wrapper for ListDelegatedServicesForAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDelegatedServicesForAccountAsync(const ListDelegatedServicesForAccountRequestT& request, const ListDelegatedServicesForAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListDelegatedServicesForAccount, request, handler, context); } /** *

Lists the current handshakes that are associated with the account of the * requesting user.

Handshakes that are ACCEPTED, * DECLINED, CANCELED, or EXPIRED appear in * the results of this API for only 30 days after changing to that state. After * that, they're deleted and no longer accessible.

Always check the * NextToken response parameter for a null value when * calling a List* operation. These operations can occasionally return * an empty set of results even when there are more results available. The * NextToken response parameter value is null only * when there are no more results to display.

This operation can be * called from any account in the organization.

See Also:

AWS * API Reference

*/ virtual Model::ListHandshakesForAccountOutcome ListHandshakesForAccount(const Model::ListHandshakesForAccountRequest& request) const; /** * A Callable wrapper for ListHandshakesForAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHandshakesForAccountOutcomeCallable ListHandshakesForAccountCallable(const ListHandshakesForAccountRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListHandshakesForAccount, request); } /** * An Async wrapper for ListHandshakesForAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHandshakesForAccountAsync(const ListHandshakesForAccountRequestT& request, const ListHandshakesForAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListHandshakesForAccount, request, handler, context); } /** *

Lists the handshakes that are associated with the organization that the * requesting user is part of. The ListHandshakesForOrganization * operation returns a list of handshake structures. Each structure contains * details and status about a handshake.

Handshakes that are * ACCEPTED, DECLINED, CANCELED, or * EXPIRED appear in the results of this API for only 30 days after * changing to that state. After that, they're deleted and no longer * accessible.

Always check the NextToken response * parameter for a null value when calling a List* * operation. These operations can occasionally return an empty set of results even * when there are more results available. The NextToken response * parameter value is null only when there are no more results * to display.

This operation can be called only from the * organization's management account or by a member account that is a delegated * administrator for an Amazon Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListHandshakesForOrganizationOutcome ListHandshakesForOrganization(const Model::ListHandshakesForOrganizationRequest& request) const; /** * A Callable wrapper for ListHandshakesForOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListHandshakesForOrganizationOutcomeCallable ListHandshakesForOrganizationCallable(const ListHandshakesForOrganizationRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListHandshakesForOrganization, request); } /** * An Async wrapper for ListHandshakesForOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListHandshakesForOrganizationAsync(const ListHandshakesForOrganizationRequestT& request, const ListHandshakesForOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListHandshakesForOrganization, request, handler, context); } /** *

Lists the organizational units (OUs) in a parent organizational unit or * root.

Always check the NextToken response parameter * for a null value when calling a List* operation. These * operations can occasionally return an empty set of results even when there are * more results available. The NextToken response parameter value is * null only when there are no more results to display.

*

This operation can be called only from the organization's management * account or by a member account that is a delegated administrator for an Amazon * Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListOrganizationalUnitsForParentOutcome ListOrganizationalUnitsForParent(const Model::ListOrganizationalUnitsForParentRequest& request) const; /** * A Callable wrapper for ListOrganizationalUnitsForParent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOrganizationalUnitsForParentOutcomeCallable ListOrganizationalUnitsForParentCallable(const ListOrganizationalUnitsForParentRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListOrganizationalUnitsForParent, request); } /** * An Async wrapper for ListOrganizationalUnitsForParent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOrganizationalUnitsForParentAsync(const ListOrganizationalUnitsForParentRequestT& request, const ListOrganizationalUnitsForParentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListOrganizationalUnitsForParent, request, handler, context); } /** *

Lists the root or organizational units (OUs) that serve as the immediate * parent of the specified child OU or account. This operation, along with * ListChildren enables you to traverse the tree structure that makes up * this root.

Always check the NextToken response * parameter for a null value when calling a List* * operation. These operations can occasionally return an empty set of results even * when there are more results available. The NextToken response * parameter value is null only when there are no more results * to display.

This operation can be called only from the * organization's management account or by a member account that is a delegated * administrator for an Amazon Web Services service.

In the current * release, a child can have only a single parent.

See Also:

* AWS * API Reference

*/ virtual Model::ListParentsOutcome ListParents(const Model::ListParentsRequest& request) const; /** * A Callable wrapper for ListParents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListParentsOutcomeCallable ListParentsCallable(const ListParentsRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListParents, request); } /** * An Async wrapper for ListParents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListParentsAsync(const ListParentsRequestT& request, const ListParentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListParents, request, handler, context); } /** *

Retrieves the list of all policies in an organization of a specified * type.

Always check the NextToken response parameter * for a null value when calling a List* operation. These * operations can occasionally return an empty set of results even when there are * more results available. The NextToken response parameter value is * null only when there are no more results to display.

*

This operation can be called only from the organization's management * account or by a member account that is a delegated administrator for an Amazon * Web Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request) const; /** * A Callable wrapper for ListPolicies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListPolicies, request); } /** * An Async wrapper for ListPolicies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPoliciesAsync(const ListPoliciesRequestT& request, const ListPoliciesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListPolicies, request, handler, context); } /** *

Lists the policies that are directly attached to the specified target root, * organizational unit (OU), or account. You must specify the policy type that you * want included in the returned list.

Always check the * NextToken response parameter for a null value when * calling a List* operation. These operations can occasionally return * an empty set of results even when there are more results available. The * NextToken response parameter value is null only * when there are no more results to display.

This operation can be * called only from the organization's management account or by a member account * that is a delegated administrator for an Amazon Web Services * service.

See Also:

AWS * API Reference

*/ virtual Model::ListPoliciesForTargetOutcome ListPoliciesForTarget(const Model::ListPoliciesForTargetRequest& request) const; /** * A Callable wrapper for ListPoliciesForTarget that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPoliciesForTargetOutcomeCallable ListPoliciesForTargetCallable(const ListPoliciesForTargetRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListPoliciesForTarget, request); } /** * An Async wrapper for ListPoliciesForTarget that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPoliciesForTargetAsync(const ListPoliciesForTargetRequestT& request, const ListPoliciesForTargetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListPoliciesForTarget, request, handler, context); } /** *

Lists the roots that are defined in the current organization.

*

Always check the NextToken response parameter for a * null value when calling a List* operation. These * operations can occasionally return an empty set of results even when there are * more results available. The NextToken response parameter value is * null only when there are no more results to display.

*

This operation can be called only from the organization's management * account or by a member account that is a delegated administrator for an Amazon * Web Services service.

Policy types can be enabled and disabled in * roots. This is distinct from whether they're available in the organization. When * you enable all features, you make policy types available for use in that * organization. Individual policy types can then be enabled and disabled in a * root. To see the availability of a policy type in an organization, use * DescribeOrganization.

See Also:

AWS * API Reference

*/ virtual Model::ListRootsOutcome ListRoots(const Model::ListRootsRequest& request) const; /** * A Callable wrapper for ListRoots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRootsOutcomeCallable ListRootsCallable(const ListRootsRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListRoots, request); } /** * An Async wrapper for ListRoots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRootsAsync(const ListRootsRequestT& request, const ListRootsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListRoots, request, handler, context); } /** *

Lists tags that are attached to the specified resource.

You can attach * tags to the following resources in Organizations.

  • Amazon Web * Services account

  • Organization root

  • *

    Organizational unit (OU)

  • Policy (any type)

*

This operation can be called only from the organization's management account * or by a member account that is a delegated administrator for an Amazon Web * Services service.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListTagsForResource, request, handler, context); } /** *

Lists all the roots, organizational units (OUs), and accounts that the * specified policy is attached to.

Always check the * NextToken response parameter for a null value when * calling a List* operation. These operations can occasionally return * an empty set of results even when there are more results available. The * NextToken response parameter value is null only * when there are no more results to display.

This operation can be * called only from the organization's management account or by a member account * that is a delegated administrator for an Amazon Web Services * service.

See Also:

AWS * API Reference

*/ virtual Model::ListTargetsForPolicyOutcome ListTargetsForPolicy(const Model::ListTargetsForPolicyRequest& request) const; /** * A Callable wrapper for ListTargetsForPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTargetsForPolicyOutcomeCallable ListTargetsForPolicyCallable(const ListTargetsForPolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::ListTargetsForPolicy, request); } /** * An Async wrapper for ListTargetsForPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTargetsForPolicyAsync(const ListTargetsForPolicyRequestT& request, const ListTargetsForPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::ListTargetsForPolicy, request, handler, context); } /** *

Moves an account from its current source parent root or organizational unit * (OU) to the specified destination parent root or OU.

This operation can * be called only from the organization's management account.

See * Also:

AWS * API Reference

*/ virtual Model::MoveAccountOutcome MoveAccount(const Model::MoveAccountRequest& request) const; /** * A Callable wrapper for MoveAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MoveAccountOutcomeCallable MoveAccountCallable(const MoveAccountRequestT& request) const { return SubmitCallable(&OrganizationsClient::MoveAccount, request); } /** * An Async wrapper for MoveAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MoveAccountAsync(const MoveAccountRequestT& request, const MoveAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::MoveAccount, request, handler, context); } /** *

Creates or updates a resource policy.

You can only call this operation * from the organization's management account.

See Also:

AWS * API Reference

*/ virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const; /** * A Callable wrapper for PutResourcePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::PutResourcePolicy, request); } /** * An Async wrapper for PutResourcePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::PutResourcePolicy, request, handler, context); } /** *

Enables the specified member account to administer the Organizations features * of the specified Amazon Web Services service. It grants read-only access to * Organizations service data. The account still requires IAM permissions to access * and administer the Amazon Web Services service.

You can run this action * only for Amazon Web Services services that support this feature. For a current * list of services that support it, see the column Supports Delegated * Administrator in the table at Amazon * Web Services Services that you can use with Organizations in the * Organizations User Guide.

This operation can be called only from * the organization's management account.

See Also:

AWS * API Reference

*/ virtual Model::RegisterDelegatedAdministratorOutcome RegisterDelegatedAdministrator(const Model::RegisterDelegatedAdministratorRequest& request) const; /** * A Callable wrapper for RegisterDelegatedAdministrator that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterDelegatedAdministratorOutcomeCallable RegisterDelegatedAdministratorCallable(const RegisterDelegatedAdministratorRequestT& request) const { return SubmitCallable(&OrganizationsClient::RegisterDelegatedAdministrator, request); } /** * An Async wrapper for RegisterDelegatedAdministrator that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterDelegatedAdministratorAsync(const RegisterDelegatedAdministratorRequestT& request, const RegisterDelegatedAdministratorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::RegisterDelegatedAdministrator, request, handler, context); } /** *

Removes the specified account from the organization.

The removed * account becomes a standalone account that isn't a member of any organization. * It's no longer subject to any policies and is responsible for its own bill * payments. The organization's management account is no longer charged for any * expenses accrued by the member account after it's removed from the * organization.

This operation can be called only from the organization's * management account. Member accounts can remove themselves with * LeaveOrganization instead.

  • You can remove an * account from your organization 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 Organizations console, API, or CLI * commands, the information required of standalone accounts is not * automatically collected. For an account that you want to make standalone, you * must choose a support plan, provide and verify the required contact information, * and provide a current payment method. Amazon Web Services uses the payment * method to charge for any billable (not free tier) Amazon Web Services activity * that occurs while the account isn't attached to an organization. To remove an * account that doesn't yet have this information, you must sign in as the member * account and follow the steps at * To leave an organization when all required account information has not yet been * provided in the Organizations User Guide.

  • The * account that you want to leave must not be a delegated administrator account for * any Amazon Web Services 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.

  • *

    After the account leaves the organization, all tags that were attached to the * account object in the organization are deleted. Amazon Web Services accounts * outside of an organization do not support tags.

*

See Also:

AWS * API Reference

*/ virtual Model::RemoveAccountFromOrganizationOutcome RemoveAccountFromOrganization(const Model::RemoveAccountFromOrganizationRequest& request) const; /** * A Callable wrapper for RemoveAccountFromOrganization that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveAccountFromOrganizationOutcomeCallable RemoveAccountFromOrganizationCallable(const RemoveAccountFromOrganizationRequestT& request) const { return SubmitCallable(&OrganizationsClient::RemoveAccountFromOrganization, request); } /** * An Async wrapper for RemoveAccountFromOrganization that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveAccountFromOrganizationAsync(const RemoveAccountFromOrganizationRequestT& request, const RemoveAccountFromOrganizationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::RemoveAccountFromOrganization, request, handler, context); } /** *

Adds one or more tags to the specified resource.

Currently, you can * attach tags to the following resources in Organizations.

  • Amazon * Web Services account

  • Organization root

  • *

    Organizational unit (OU)

  • Policy (any type)

*

This operation can be called only from the organization's management * account.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&OrganizationsClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::TagResource, request, handler, context); } /** *

Removes any tags with the specified keys from the specified resource.

*

You can attach tags to the following resources in Organizations.

    *

  • Amazon Web Services account

  • Organization root

    *

  • Organizational unit (OU)

  • Policy (any type)

    *

This operation can be called only from the organization's * management account.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&OrganizationsClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::UntagResource, request, handler, context); } /** *

Renames the specified organizational unit (OU). The ID and ARN don't change. * The child OUs and accounts remain in place, and any attached policies of the OU * remain attached.

This operation can be called only from the * organization's management account.

See Also:

AWS * API Reference

*/ virtual Model::UpdateOrganizationalUnitOutcome UpdateOrganizationalUnit(const Model::UpdateOrganizationalUnitRequest& request) const; /** * A Callable wrapper for UpdateOrganizationalUnit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateOrganizationalUnitOutcomeCallable UpdateOrganizationalUnitCallable(const UpdateOrganizationalUnitRequestT& request) const { return SubmitCallable(&OrganizationsClient::UpdateOrganizationalUnit, request); } /** * An Async wrapper for UpdateOrganizationalUnit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateOrganizationalUnitAsync(const UpdateOrganizationalUnitRequestT& request, const UpdateOrganizationalUnitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::UpdateOrganizationalUnit, request, handler, context); } /** *

Updates an existing policy with a new name, description, or content. If you * don't supply any parameter, that value remains unchanged. You can't change a * policy's type.

This operation can be called only from the organization's * management account.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePolicyOutcome UpdatePolicy(const Model::UpdatePolicyRequest& request) const; /** * A Callable wrapper for UpdatePolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePolicyOutcomeCallable UpdatePolicyCallable(const UpdatePolicyRequestT& request) const { return SubmitCallable(&OrganizationsClient::UpdatePolicy, request); } /** * An Async wrapper for UpdatePolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePolicyAsync(const UpdatePolicyRequestT& request, const UpdatePolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&OrganizationsClient::UpdatePolicy, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const OrganizationsClientConfiguration& clientConfiguration); OrganizationsClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Organizations } // namespace Aws