OrganizationsClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/organizations/OrganizationsPaginationBase.h>
#include <aws/organizations/OrganizationsServiceClientModel.h>
#include <aws/organizations/Organizations_EXPORTS.h>
 
namespace Aws {
namespace Organizations {
class AWS_ORGANIZATIONS_API OrganizationsClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<OrganizationsClient>,
                                                  public OrganizationsPaginationBase<OrganizationsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef OrganizationsClientConfiguration ClientConfigurationType;
  typedef OrganizationsEndpointProvider EndpointProviderType;
 
  OrganizationsClient(const Aws::Organizations::OrganizationsClientConfiguration& clientConfiguration =
                          Aws::Organizations::OrganizationsClientConfiguration(),
                      std::shared_ptr<OrganizationsEndpointProviderBase> endpointProvider = nullptr);
 
  OrganizationsClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<OrganizationsEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Organizations::OrganizationsClientConfiguration& clientConfiguration =
                          Aws::Organizations::OrganizationsClientConfiguration());
 
  OrganizationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<OrganizationsEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Organizations::OrganizationsClientConfiguration& clientConfiguration =
                          Aws::Organizations::OrganizationsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  OrganizationsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OrganizationsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OrganizationsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~OrganizationsClient();
 
  virtual Model::AcceptHandshakeOutcome AcceptHandshake(const Model::AcceptHandshakeRequest& request) const;
 
  template <typename AcceptHandshakeRequestT = Model::AcceptHandshakeRequest>
  Model::AcceptHandshakeOutcomeCallable AcceptHandshakeCallable(const AcceptHandshakeRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::AcceptHandshake, request);
  }
 
  template <typename AcceptHandshakeRequestT = Model::AcceptHandshakeRequest>
  void AcceptHandshakeAsync(const AcceptHandshakeRequestT& request, const AcceptHandshakeResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::AcceptHandshake, request, handler, context);
  }
 
  virtual Model::AttachPolicyOutcome AttachPolicy(const Model::AttachPolicyRequest& request) const;
 
  template <typename AttachPolicyRequestT = Model::AttachPolicyRequest>
  Model::AttachPolicyOutcomeCallable AttachPolicyCallable(const AttachPolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::AttachPolicy, request);
  }
 
  template <typename AttachPolicyRequestT = Model::AttachPolicyRequest>
  void AttachPolicyAsync(const AttachPolicyRequestT& request, const AttachPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::AttachPolicy, request, handler, context);
  }
 
  virtual Model::CancelHandshakeOutcome CancelHandshake(const Model::CancelHandshakeRequest& request) const;
 
  template <typename CancelHandshakeRequestT = Model::CancelHandshakeRequest>
  Model::CancelHandshakeOutcomeCallable CancelHandshakeCallable(const CancelHandshakeRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::CancelHandshake, request);
  }
 
  template <typename CancelHandshakeRequestT = Model::CancelHandshakeRequest>
  void CancelHandshakeAsync(const CancelHandshakeRequestT& request, const CancelHandshakeResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::CancelHandshake, request, handler, context);
  }
 
  virtual Model::CloseAccountOutcome CloseAccount(const Model::CloseAccountRequest& request) const;
 
  template <typename CloseAccountRequestT = Model::CloseAccountRequest>
  Model::CloseAccountOutcomeCallable CloseAccountCallable(const CloseAccountRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::CloseAccount, request);
  }
 
  template <typename CloseAccountRequestT = Model::CloseAccountRequest>
  void CloseAccountAsync(const CloseAccountRequestT& request, const CloseAccountResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::CloseAccount, request, handler, context);
  }
 
  virtual Model::CreateAccountOutcome CreateAccount(const Model::CreateAccountRequest& request) const;
 
  template <typename CreateAccountRequestT = Model::CreateAccountRequest>
  Model::CreateAccountOutcomeCallable CreateAccountCallable(const CreateAccountRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::CreateAccount, request);
  }
 
  template <typename CreateAccountRequestT = Model::CreateAccountRequest>
  void CreateAccountAsync(const CreateAccountRequestT& request, const CreateAccountResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::CreateAccount, request, handler, context);
  }
 
  virtual Model::CreateGovCloudAccountOutcome CreateGovCloudAccount(const Model::CreateGovCloudAccountRequest& request) const;
 
  template <typename CreateGovCloudAccountRequestT = Model::CreateGovCloudAccountRequest>
  Model::CreateGovCloudAccountOutcomeCallable CreateGovCloudAccountCallable(const CreateGovCloudAccountRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::CreateGovCloudAccount, request);
  }
 
  template <typename CreateGovCloudAccountRequestT = Model::CreateGovCloudAccountRequest>
  void CreateGovCloudAccountAsync(const CreateGovCloudAccountRequestT& request, const CreateGovCloudAccountResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::CreateGovCloudAccount, request, handler, context);
  }
 
  virtual Model::CreateOrganizationOutcome CreateOrganization(const Model::CreateOrganizationRequest& request = {}) const;
 
  template <typename CreateOrganizationRequestT = Model::CreateOrganizationRequest>
  Model::CreateOrganizationOutcomeCallable CreateOrganizationCallable(const CreateOrganizationRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::CreateOrganization, request);
  }
 
  template <typename CreateOrganizationRequestT = Model::CreateOrganizationRequest>
  void CreateOrganizationAsync(const CreateOrganizationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const CreateOrganizationRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::CreateOrganization, request, handler, context);
  }
 
  virtual Model::CreateOrganizationalUnitOutcome CreateOrganizationalUnit(const Model::CreateOrganizationalUnitRequest& request) const;
 
  template <typename CreateOrganizationalUnitRequestT = Model::CreateOrganizationalUnitRequest>
  Model::CreateOrganizationalUnitOutcomeCallable CreateOrganizationalUnitCallable(const CreateOrganizationalUnitRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::CreateOrganizationalUnit, request);
  }
 
  template <typename CreateOrganizationalUnitRequestT = Model::CreateOrganizationalUnitRequest>
  void CreateOrganizationalUnitAsync(const CreateOrganizationalUnitRequestT& request,
                                     const CreateOrganizationalUnitResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::CreateOrganizationalUnit, request, handler, context);
  }
 
  virtual Model::CreatePolicyOutcome CreatePolicy(const Model::CreatePolicyRequest& request) const;
 
  template <typename CreatePolicyRequestT = Model::CreatePolicyRequest>
  Model::CreatePolicyOutcomeCallable CreatePolicyCallable(const CreatePolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::CreatePolicy, request);
  }
 
  template <typename CreatePolicyRequestT = Model::CreatePolicyRequest>
  void CreatePolicyAsync(const CreatePolicyRequestT& request, const CreatePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::CreatePolicy, request, handler, context);
  }
 
  virtual Model::DeclineHandshakeOutcome DeclineHandshake(const Model::DeclineHandshakeRequest& request) const;
 
  template <typename DeclineHandshakeRequestT = Model::DeclineHandshakeRequest>
  Model::DeclineHandshakeOutcomeCallable DeclineHandshakeCallable(const DeclineHandshakeRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DeclineHandshake, request);
  }
 
  template <typename DeclineHandshakeRequestT = Model::DeclineHandshakeRequest>
  void DeclineHandshakeAsync(const DeclineHandshakeRequestT& request, const DeclineHandshakeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DeclineHandshake, request, handler, context);
  }
 
  virtual Model::DeleteOrganizationOutcome DeleteOrganization(const Model::DeleteOrganizationRequest& request = {}) const;
 
  template <typename DeleteOrganizationRequestT = Model::DeleteOrganizationRequest>
  Model::DeleteOrganizationOutcomeCallable DeleteOrganizationCallable(const DeleteOrganizationRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::DeleteOrganization, request);
  }
 
  template <typename DeleteOrganizationRequestT = Model::DeleteOrganizationRequest>
  void DeleteOrganizationAsync(const DeleteOrganizationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DeleteOrganizationRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::DeleteOrganization, request, handler, context);
  }
 
  virtual Model::DeleteOrganizationalUnitOutcome DeleteOrganizationalUnit(const Model::DeleteOrganizationalUnitRequest& request) const;
 
  template <typename DeleteOrganizationalUnitRequestT = Model::DeleteOrganizationalUnitRequest>
  Model::DeleteOrganizationalUnitOutcomeCallable DeleteOrganizationalUnitCallable(const DeleteOrganizationalUnitRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DeleteOrganizationalUnit, request);
  }
 
  template <typename DeleteOrganizationalUnitRequestT = Model::DeleteOrganizationalUnitRequest>
  void DeleteOrganizationalUnitAsync(const DeleteOrganizationalUnitRequestT& request,
                                     const DeleteOrganizationalUnitResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DeleteOrganizationalUnit, request, handler, context);
  }
 
  virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request) const;
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DeletePolicy, request);
  }
 
  template <typename DeletePolicyRequestT = Model::DeletePolicyRequest>
  void DeletePolicyAsync(const DeletePolicyRequestT& request, const DeletePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DeletePolicy, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request = {}) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DeleteResourcePolicyRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeregisterDelegatedAdministratorOutcome DeregisterDelegatedAdministrator(
      const Model::DeregisterDelegatedAdministratorRequest& request) const;
 
  template <typename DeregisterDelegatedAdministratorRequestT = Model::DeregisterDelegatedAdministratorRequest>
  Model::DeregisterDelegatedAdministratorOutcomeCallable DeregisterDelegatedAdministratorCallable(
      const DeregisterDelegatedAdministratorRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DeregisterDelegatedAdministrator, request);
  }
 
  template <typename DeregisterDelegatedAdministratorRequestT = Model::DeregisterDelegatedAdministratorRequest>
  void DeregisterDelegatedAdministratorAsync(const DeregisterDelegatedAdministratorRequestT& request,
                                             const DeregisterDelegatedAdministratorResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DeregisterDelegatedAdministrator, request, handler, context);
  }
 
  virtual Model::DescribeAccountOutcome DescribeAccount(const Model::DescribeAccountRequest& request) const;
 
  template <typename DescribeAccountRequestT = Model::DescribeAccountRequest>
  Model::DescribeAccountOutcomeCallable DescribeAccountCallable(const DescribeAccountRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DescribeAccount, request);
  }
 
  template <typename DescribeAccountRequestT = Model::DescribeAccountRequest>
  void DescribeAccountAsync(const DescribeAccountRequestT& request, const DescribeAccountResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DescribeAccount, request, handler, context);
  }
 
  virtual Model::DescribeCreateAccountStatusOutcome DescribeCreateAccountStatus(
      const Model::DescribeCreateAccountStatusRequest& request) const;
 
  template <typename DescribeCreateAccountStatusRequestT = Model::DescribeCreateAccountStatusRequest>
  Model::DescribeCreateAccountStatusOutcomeCallable DescribeCreateAccountStatusCallable(
      const DescribeCreateAccountStatusRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DescribeCreateAccountStatus, request);
  }
 
  template <typename DescribeCreateAccountStatusRequestT = Model::DescribeCreateAccountStatusRequest>
  void DescribeCreateAccountStatusAsync(const DescribeCreateAccountStatusRequestT& request,
                                        const DescribeCreateAccountStatusResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DescribeCreateAccountStatus, request, handler, context);
  }
 
  virtual Model::DescribeEffectivePolicyOutcome DescribeEffectivePolicy(const Model::DescribeEffectivePolicyRequest& request) const;
 
  template <typename DescribeEffectivePolicyRequestT = Model::DescribeEffectivePolicyRequest>
  Model::DescribeEffectivePolicyOutcomeCallable DescribeEffectivePolicyCallable(const DescribeEffectivePolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DescribeEffectivePolicy, request);
  }
 
  template <typename DescribeEffectivePolicyRequestT = Model::DescribeEffectivePolicyRequest>
  void DescribeEffectivePolicyAsync(const DescribeEffectivePolicyRequestT& request,
                                    const DescribeEffectivePolicyResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DescribeEffectivePolicy, request, handler, context);
  }
 
  virtual Model::DescribeHandshakeOutcome DescribeHandshake(const Model::DescribeHandshakeRequest& request) const;
 
  template <typename DescribeHandshakeRequestT = Model::DescribeHandshakeRequest>
  Model::DescribeHandshakeOutcomeCallable DescribeHandshakeCallable(const DescribeHandshakeRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DescribeHandshake, request);
  }
 
  template <typename DescribeHandshakeRequestT = Model::DescribeHandshakeRequest>
  void DescribeHandshakeAsync(const DescribeHandshakeRequestT& request, const DescribeHandshakeResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DescribeHandshake, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationOutcome DescribeOrganization(const Model::DescribeOrganizationRequest& request = {}) const;
 
  template <typename DescribeOrganizationRequestT = Model::DescribeOrganizationRequest>
  Model::DescribeOrganizationOutcomeCallable DescribeOrganizationCallable(const DescribeOrganizationRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::DescribeOrganization, request);
  }
 
  template <typename DescribeOrganizationRequestT = Model::DescribeOrganizationRequest>
  void DescribeOrganizationAsync(const DescribeOrganizationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeOrganizationRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::DescribeOrganization, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationalUnitOutcome DescribeOrganizationalUnit(
      const Model::DescribeOrganizationalUnitRequest& request) const;
 
  template <typename DescribeOrganizationalUnitRequestT = Model::DescribeOrganizationalUnitRequest>
  Model::DescribeOrganizationalUnitOutcomeCallable DescribeOrganizationalUnitCallable(
      const DescribeOrganizationalUnitRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DescribeOrganizationalUnit, request);
  }
 
  template <typename DescribeOrganizationalUnitRequestT = Model::DescribeOrganizationalUnitRequest>
  void DescribeOrganizationalUnitAsync(const DescribeOrganizationalUnitRequestT& request,
                                       const DescribeOrganizationalUnitResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DescribeOrganizationalUnit, request, handler, context);
  }
 
  virtual Model::DescribePolicyOutcome DescribePolicy(const Model::DescribePolicyRequest& request) const;
 
  template <typename DescribePolicyRequestT = Model::DescribePolicyRequest>
  Model::DescribePolicyOutcomeCallable DescribePolicyCallable(const DescribePolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DescribePolicy, request);
  }
 
  template <typename DescribePolicyRequestT = Model::DescribePolicyRequest>
  void DescribePolicyAsync(const DescribePolicyRequestT& request, const DescribePolicyResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DescribePolicy, request, handler, context);
  }
 
  virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy(const Model::DescribeResourcePolicyRequest& request = {}) const;
 
  template <typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
  Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable(const DescribeResourcePolicyRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::DescribeResourcePolicy, request);
  }
 
  template <typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
  void DescribeResourcePolicyAsync(const DescribeResourcePolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DescribeResourcePolicyRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::DescribeResourcePolicy, request, handler, context);
  }
 
  virtual Model::DescribeResponsibilityTransferOutcome DescribeResponsibilityTransfer(
      const Model::DescribeResponsibilityTransferRequest& request) const;
 
  template <typename DescribeResponsibilityTransferRequestT = Model::DescribeResponsibilityTransferRequest>
  Model::DescribeResponsibilityTransferOutcomeCallable DescribeResponsibilityTransferCallable(
      const DescribeResponsibilityTransferRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DescribeResponsibilityTransfer, request);
  }
 
  template <typename DescribeResponsibilityTransferRequestT = Model::DescribeResponsibilityTransferRequest>
  void DescribeResponsibilityTransferAsync(const DescribeResponsibilityTransferRequestT& request,
                                           const DescribeResponsibilityTransferResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DescribeResponsibilityTransfer, request, handler, context);
  }
 
  virtual Model::DetachPolicyOutcome DetachPolicy(const Model::DetachPolicyRequest& request) const;
 
  template <typename DetachPolicyRequestT = Model::DetachPolicyRequest>
  Model::DetachPolicyOutcomeCallable DetachPolicyCallable(const DetachPolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DetachPolicy, request);
  }
 
  template <typename DetachPolicyRequestT = Model::DetachPolicyRequest>
  void DetachPolicyAsync(const DetachPolicyRequestT& request, const DetachPolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DetachPolicy, request, handler, context);
  }
 
  virtual Model::DisableAWSServiceAccessOutcome DisableAWSServiceAccess(const Model::DisableAWSServiceAccessRequest& request) const;
 
  template <typename DisableAWSServiceAccessRequestT = Model::DisableAWSServiceAccessRequest>
  Model::DisableAWSServiceAccessOutcomeCallable DisableAWSServiceAccessCallable(const DisableAWSServiceAccessRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DisableAWSServiceAccess, request);
  }
 
  template <typename DisableAWSServiceAccessRequestT = Model::DisableAWSServiceAccessRequest>
  void DisableAWSServiceAccessAsync(const DisableAWSServiceAccessRequestT& request,
                                    const DisableAWSServiceAccessResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DisableAWSServiceAccess, request, handler, context);
  }
 
  virtual Model::DisablePolicyTypeOutcome DisablePolicyType(const Model::DisablePolicyTypeRequest& request) const;
 
  template <typename DisablePolicyTypeRequestT = Model::DisablePolicyTypeRequest>
  Model::DisablePolicyTypeOutcomeCallable DisablePolicyTypeCallable(const DisablePolicyTypeRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::DisablePolicyType, request);
  }
 
  template <typename DisablePolicyTypeRequestT = Model::DisablePolicyTypeRequest>
  void DisablePolicyTypeAsync(const DisablePolicyTypeRequestT& request, const DisablePolicyTypeResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::DisablePolicyType, request, handler, context);
  }
 
  virtual Model::EnableAWSServiceAccessOutcome EnableAWSServiceAccess(const Model::EnableAWSServiceAccessRequest& request) const;
 
  template <typename EnableAWSServiceAccessRequestT = Model::EnableAWSServiceAccessRequest>
  Model::EnableAWSServiceAccessOutcomeCallable EnableAWSServiceAccessCallable(const EnableAWSServiceAccessRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::EnableAWSServiceAccess, request);
  }
 
  template <typename EnableAWSServiceAccessRequestT = Model::EnableAWSServiceAccessRequest>
  void EnableAWSServiceAccessAsync(const EnableAWSServiceAccessRequestT& request,
                                   const EnableAWSServiceAccessResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::EnableAWSServiceAccess, request, handler, context);
  }
 
  virtual Model::EnableAllFeaturesOutcome EnableAllFeatures(const Model::EnableAllFeaturesRequest& request = {}) const;
 
  template <typename EnableAllFeaturesRequestT = Model::EnableAllFeaturesRequest>
  Model::EnableAllFeaturesOutcomeCallable EnableAllFeaturesCallable(const EnableAllFeaturesRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::EnableAllFeatures, request);
  }
 
  template <typename EnableAllFeaturesRequestT = Model::EnableAllFeaturesRequest>
  void EnableAllFeaturesAsync(const EnableAllFeaturesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const EnableAllFeaturesRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::EnableAllFeatures, request, handler, context);
  }
 
  virtual Model::EnablePolicyTypeOutcome EnablePolicyType(const Model::EnablePolicyTypeRequest& request) const;
 
  template <typename EnablePolicyTypeRequestT = Model::EnablePolicyTypeRequest>
  Model::EnablePolicyTypeOutcomeCallable EnablePolicyTypeCallable(const EnablePolicyTypeRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::EnablePolicyType, request);
  }
 
  template <typename EnablePolicyTypeRequestT = Model::EnablePolicyTypeRequest>
  void EnablePolicyTypeAsync(const EnablePolicyTypeRequestT& request, const EnablePolicyTypeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::EnablePolicyType, request, handler, context);
  }
 
  virtual Model::InviteAccountToOrganizationOutcome InviteAccountToOrganization(
      const Model::InviteAccountToOrganizationRequest& request) const;
 
  template <typename InviteAccountToOrganizationRequestT = Model::InviteAccountToOrganizationRequest>
  Model::InviteAccountToOrganizationOutcomeCallable InviteAccountToOrganizationCallable(
      const InviteAccountToOrganizationRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::InviteAccountToOrganization, request);
  }
 
  template <typename InviteAccountToOrganizationRequestT = Model::InviteAccountToOrganizationRequest>
  void InviteAccountToOrganizationAsync(const InviteAccountToOrganizationRequestT& request,
                                        const InviteAccountToOrganizationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::InviteAccountToOrganization, request, handler, context);
  }
 
  virtual Model::InviteOrganizationToTransferResponsibilityOutcome InviteOrganizationToTransferResponsibility(
      const Model::InviteOrganizationToTransferResponsibilityRequest& request) const;
 
  template <typename InviteOrganizationToTransferResponsibilityRequestT = Model::InviteOrganizationToTransferResponsibilityRequest>
  Model::InviteOrganizationToTransferResponsibilityOutcomeCallable InviteOrganizationToTransferResponsibilityCallable(
      const InviteOrganizationToTransferResponsibilityRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::InviteOrganizationToTransferResponsibility, request);
  }
 
  template <typename InviteOrganizationToTransferResponsibilityRequestT = Model::InviteOrganizationToTransferResponsibilityRequest>
  void InviteOrganizationToTransferResponsibilityAsync(
      const InviteOrganizationToTransferResponsibilityRequestT& request,
      const InviteOrganizationToTransferResponsibilityResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::InviteOrganizationToTransferResponsibility, request, handler, context);
  }
 
  virtual Model::LeaveOrganizationOutcome LeaveOrganization(const Model::LeaveOrganizationRequest& request = {}) const;
 
  template <typename LeaveOrganizationRequestT = Model::LeaveOrganizationRequest>
  Model::LeaveOrganizationOutcomeCallable LeaveOrganizationCallable(const LeaveOrganizationRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::LeaveOrganization, request);
  }
 
  template <typename LeaveOrganizationRequestT = Model::LeaveOrganizationRequest>
  void LeaveOrganizationAsync(const LeaveOrganizationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const LeaveOrganizationRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::LeaveOrganization, request, handler, context);
  }
 
  virtual Model::ListAWSServiceAccessForOrganizationOutcome ListAWSServiceAccessForOrganization(
      const Model::ListAWSServiceAccessForOrganizationRequest& request = {}) const;
 
  template <typename ListAWSServiceAccessForOrganizationRequestT = Model::ListAWSServiceAccessForOrganizationRequest>
  Model::ListAWSServiceAccessForOrganizationOutcomeCallable ListAWSServiceAccessForOrganizationCallable(
      const ListAWSServiceAccessForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::ListAWSServiceAccessForOrganization, request);
  }
 
  template <typename ListAWSServiceAccessForOrganizationRequestT = Model::ListAWSServiceAccessForOrganizationRequest>
  void ListAWSServiceAccessForOrganizationAsync(const ListAWSServiceAccessForOrganizationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const ListAWSServiceAccessForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::ListAWSServiceAccessForOrganization, request, handler, context);
  }
 
  virtual Model::ListAccountsOutcome ListAccounts(const Model::ListAccountsRequest& request = {}) const;
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  Model::ListAccountsOutcomeCallable ListAccountsCallable(const ListAccountsRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::ListAccounts, request);
  }
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  void ListAccountsAsync(const ListAccountsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListAccountsRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::ListAccounts, request, handler, context);
  }
 
  virtual Model::ListAccountsForParentOutcome ListAccountsForParent(const Model::ListAccountsForParentRequest& request) const;
 
  template <typename ListAccountsForParentRequestT = Model::ListAccountsForParentRequest>
  Model::ListAccountsForParentOutcomeCallable ListAccountsForParentCallable(const ListAccountsForParentRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListAccountsForParent, request);
  }
 
  template <typename ListAccountsForParentRequestT = Model::ListAccountsForParentRequest>
  void ListAccountsForParentAsync(const ListAccountsForParentRequestT& request, const ListAccountsForParentResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListAccountsForParent, request, handler, context);
  }
 
  virtual Model::ListAccountsWithInvalidEffectivePolicyOutcome ListAccountsWithInvalidEffectivePolicy(
      const Model::ListAccountsWithInvalidEffectivePolicyRequest& request) const;
 
  template <typename ListAccountsWithInvalidEffectivePolicyRequestT = Model::ListAccountsWithInvalidEffectivePolicyRequest>
  Model::ListAccountsWithInvalidEffectivePolicyOutcomeCallable ListAccountsWithInvalidEffectivePolicyCallable(
      const ListAccountsWithInvalidEffectivePolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListAccountsWithInvalidEffectivePolicy, request);
  }
 
  template <typename ListAccountsWithInvalidEffectivePolicyRequestT = Model::ListAccountsWithInvalidEffectivePolicyRequest>
  void ListAccountsWithInvalidEffectivePolicyAsync(const ListAccountsWithInvalidEffectivePolicyRequestT& request,
                                                   const ListAccountsWithInvalidEffectivePolicyResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListAccountsWithInvalidEffectivePolicy, request, handler, context);
  }
 
  virtual Model::ListChildrenOutcome ListChildren(const Model::ListChildrenRequest& request) const;
 
  template <typename ListChildrenRequestT = Model::ListChildrenRequest>
  Model::ListChildrenOutcomeCallable ListChildrenCallable(const ListChildrenRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListChildren, request);
  }
 
  template <typename ListChildrenRequestT = Model::ListChildrenRequest>
  void ListChildrenAsync(const ListChildrenRequestT& request, const ListChildrenResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListChildren, request, handler, context);
  }
 
  virtual Model::ListCreateAccountStatusOutcome ListCreateAccountStatus(const Model::ListCreateAccountStatusRequest& request = {}) const;
 
  template <typename ListCreateAccountStatusRequestT = Model::ListCreateAccountStatusRequest>
  Model::ListCreateAccountStatusOutcomeCallable ListCreateAccountStatusCallable(const ListCreateAccountStatusRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::ListCreateAccountStatus, request);
  }
 
  template <typename ListCreateAccountStatusRequestT = Model::ListCreateAccountStatusRequest>
  void ListCreateAccountStatusAsync(const ListCreateAccountStatusResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListCreateAccountStatusRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::ListCreateAccountStatus, request, handler, context);
  }
 
  virtual Model::ListDelegatedAdministratorsOutcome ListDelegatedAdministrators(
      const Model::ListDelegatedAdministratorsRequest& request = {}) const;
 
  template <typename ListDelegatedAdministratorsRequestT = Model::ListDelegatedAdministratorsRequest>
  Model::ListDelegatedAdministratorsOutcomeCallable ListDelegatedAdministratorsCallable(
      const ListDelegatedAdministratorsRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::ListDelegatedAdministrators, request);
  }
 
  template <typename ListDelegatedAdministratorsRequestT = Model::ListDelegatedAdministratorsRequest>
  void ListDelegatedAdministratorsAsync(const ListDelegatedAdministratorsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListDelegatedAdministratorsRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::ListDelegatedAdministrators, request, handler, context);
  }
 
  virtual Model::ListDelegatedServicesForAccountOutcome ListDelegatedServicesForAccount(
      const Model::ListDelegatedServicesForAccountRequest& request) const;
 
  template <typename ListDelegatedServicesForAccountRequestT = Model::ListDelegatedServicesForAccountRequest>
  Model::ListDelegatedServicesForAccountOutcomeCallable ListDelegatedServicesForAccountCallable(
      const ListDelegatedServicesForAccountRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListDelegatedServicesForAccount, request);
  }
 
  template <typename ListDelegatedServicesForAccountRequestT = Model::ListDelegatedServicesForAccountRequest>
  void ListDelegatedServicesForAccountAsync(const ListDelegatedServicesForAccountRequestT& request,
                                            const ListDelegatedServicesForAccountResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListDelegatedServicesForAccount, request, handler, context);
  }
 
  virtual Model::ListEffectivePolicyValidationErrorsOutcome ListEffectivePolicyValidationErrors(
      const Model::ListEffectivePolicyValidationErrorsRequest& request) const;
 
  template <typename ListEffectivePolicyValidationErrorsRequestT = Model::ListEffectivePolicyValidationErrorsRequest>
  Model::ListEffectivePolicyValidationErrorsOutcomeCallable ListEffectivePolicyValidationErrorsCallable(
      const ListEffectivePolicyValidationErrorsRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListEffectivePolicyValidationErrors, request);
  }
 
  template <typename ListEffectivePolicyValidationErrorsRequestT = Model::ListEffectivePolicyValidationErrorsRequest>
  void ListEffectivePolicyValidationErrorsAsync(const ListEffectivePolicyValidationErrorsRequestT& request,
                                                const ListEffectivePolicyValidationErrorsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListEffectivePolicyValidationErrors, request, handler, context);
  }
 
  virtual Model::ListHandshakesForAccountOutcome ListHandshakesForAccount(const Model::ListHandshakesForAccountRequest& request = {}) const;
 
  template <typename ListHandshakesForAccountRequestT = Model::ListHandshakesForAccountRequest>
  Model::ListHandshakesForAccountOutcomeCallable ListHandshakesForAccountCallable(
      const ListHandshakesForAccountRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::ListHandshakesForAccount, request);
  }
 
  template <typename ListHandshakesForAccountRequestT = Model::ListHandshakesForAccountRequest>
  void ListHandshakesForAccountAsync(const ListHandshakesForAccountResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListHandshakesForAccountRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::ListHandshakesForAccount, request, handler, context);
  }
 
  virtual Model::ListHandshakesForOrganizationOutcome ListHandshakesForOrganization(
      const Model::ListHandshakesForOrganizationRequest& request = {}) const;
 
  template <typename ListHandshakesForOrganizationRequestT = Model::ListHandshakesForOrganizationRequest>
  Model::ListHandshakesForOrganizationOutcomeCallable ListHandshakesForOrganizationCallable(
      const ListHandshakesForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::ListHandshakesForOrganization, request);
  }
 
  template <typename ListHandshakesForOrganizationRequestT = Model::ListHandshakesForOrganizationRequest>
  void ListHandshakesForOrganizationAsync(const ListHandshakesForOrganizationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ListHandshakesForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::ListHandshakesForOrganization, request, handler, context);
  }
 
  virtual Model::ListInboundResponsibilityTransfersOutcome ListInboundResponsibilityTransfers(
      const Model::ListInboundResponsibilityTransfersRequest& request) const;
 
  template <typename ListInboundResponsibilityTransfersRequestT = Model::ListInboundResponsibilityTransfersRequest>
  Model::ListInboundResponsibilityTransfersOutcomeCallable ListInboundResponsibilityTransfersCallable(
      const ListInboundResponsibilityTransfersRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListInboundResponsibilityTransfers, request);
  }
 
  template <typename ListInboundResponsibilityTransfersRequestT = Model::ListInboundResponsibilityTransfersRequest>
  void ListInboundResponsibilityTransfersAsync(const ListInboundResponsibilityTransfersRequestT& request,
                                               const ListInboundResponsibilityTransfersResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListInboundResponsibilityTransfers, request, handler, context);
  }
 
  virtual Model::ListOrganizationalUnitsForParentOutcome ListOrganizationalUnitsForParent(
      const Model::ListOrganizationalUnitsForParentRequest& request) const;
 
  template <typename ListOrganizationalUnitsForParentRequestT = Model::ListOrganizationalUnitsForParentRequest>
  Model::ListOrganizationalUnitsForParentOutcomeCallable ListOrganizationalUnitsForParentCallable(
      const ListOrganizationalUnitsForParentRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListOrganizationalUnitsForParent, request);
  }
 
  template <typename ListOrganizationalUnitsForParentRequestT = Model::ListOrganizationalUnitsForParentRequest>
  void ListOrganizationalUnitsForParentAsync(const ListOrganizationalUnitsForParentRequestT& request,
                                             const ListOrganizationalUnitsForParentResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListOrganizationalUnitsForParent, request, handler, context);
  }
 
  virtual Model::ListOutboundResponsibilityTransfersOutcome ListOutboundResponsibilityTransfers(
      const Model::ListOutboundResponsibilityTransfersRequest& request) const;
 
  template <typename ListOutboundResponsibilityTransfersRequestT = Model::ListOutboundResponsibilityTransfersRequest>
  Model::ListOutboundResponsibilityTransfersOutcomeCallable ListOutboundResponsibilityTransfersCallable(
      const ListOutboundResponsibilityTransfersRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListOutboundResponsibilityTransfers, request);
  }
 
  template <typename ListOutboundResponsibilityTransfersRequestT = Model::ListOutboundResponsibilityTransfersRequest>
  void ListOutboundResponsibilityTransfersAsync(const ListOutboundResponsibilityTransfersRequestT& request,
                                                const ListOutboundResponsibilityTransfersResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListOutboundResponsibilityTransfers, request, handler, context);
  }
 
  virtual Model::ListParentsOutcome ListParents(const Model::ListParentsRequest& request) const;
 
  template <typename ListParentsRequestT = Model::ListParentsRequest>
  Model::ListParentsOutcomeCallable ListParentsCallable(const ListParentsRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListParents, request);
  }
 
  template <typename ListParentsRequestT = Model::ListParentsRequest>
  void ListParentsAsync(const ListParentsRequestT& request, const ListParentsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListParents, request, handler, context);
  }
 
  virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request) const;
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListPolicies, request);
  }
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  void ListPoliciesAsync(const ListPoliciesRequestT& request, const ListPoliciesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListPolicies, request, handler, context);
  }
 
  virtual Model::ListPoliciesForTargetOutcome ListPoliciesForTarget(const Model::ListPoliciesForTargetRequest& request) const;
 
  template <typename ListPoliciesForTargetRequestT = Model::ListPoliciesForTargetRequest>
  Model::ListPoliciesForTargetOutcomeCallable ListPoliciesForTargetCallable(const ListPoliciesForTargetRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListPoliciesForTarget, request);
  }
 
  template <typename ListPoliciesForTargetRequestT = Model::ListPoliciesForTargetRequest>
  void ListPoliciesForTargetAsync(const ListPoliciesForTargetRequestT& request, const ListPoliciesForTargetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListPoliciesForTarget, request, handler, context);
  }
 
  virtual Model::ListRootsOutcome ListRoots(const Model::ListRootsRequest& request = {}) const;
 
  template <typename ListRootsRequestT = Model::ListRootsRequest>
  Model::ListRootsOutcomeCallable ListRootsCallable(const ListRootsRequestT& request = {}) const {
    return SubmitCallable(&OrganizationsClient::ListRoots, request);
  }
 
  template <typename ListRootsRequestT = Model::ListRootsRequest>
  void ListRootsAsync(const ListRootsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListRootsRequestT& request = {}) const {
    return SubmitAsync(&OrganizationsClient::ListRoots, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTargetsForPolicyOutcome ListTargetsForPolicy(const Model::ListTargetsForPolicyRequest& request) const;
 
  template <typename ListTargetsForPolicyRequestT = Model::ListTargetsForPolicyRequest>
  Model::ListTargetsForPolicyOutcomeCallable ListTargetsForPolicyCallable(const ListTargetsForPolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::ListTargetsForPolicy, request);
  }
 
  template <typename ListTargetsForPolicyRequestT = Model::ListTargetsForPolicyRequest>
  void ListTargetsForPolicyAsync(const ListTargetsForPolicyRequestT& request, const ListTargetsForPolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::ListTargetsForPolicy, request, handler, context);
  }
 
  virtual Model::MoveAccountOutcome MoveAccount(const Model::MoveAccountRequest& request) const;
 
  template <typename MoveAccountRequestT = Model::MoveAccountRequest>
  Model::MoveAccountOutcomeCallable MoveAccountCallable(const MoveAccountRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::MoveAccount, request);
  }
 
  template <typename MoveAccountRequestT = Model::MoveAccountRequest>
  void MoveAccountAsync(const MoveAccountRequestT& request, const MoveAccountResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::MoveAccount, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::RegisterDelegatedAdministratorOutcome RegisterDelegatedAdministrator(
      const Model::RegisterDelegatedAdministratorRequest& request) const;
 
  template <typename RegisterDelegatedAdministratorRequestT = Model::RegisterDelegatedAdministratorRequest>
  Model::RegisterDelegatedAdministratorOutcomeCallable RegisterDelegatedAdministratorCallable(
      const RegisterDelegatedAdministratorRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::RegisterDelegatedAdministrator, request);
  }
 
  template <typename RegisterDelegatedAdministratorRequestT = Model::RegisterDelegatedAdministratorRequest>
  void RegisterDelegatedAdministratorAsync(const RegisterDelegatedAdministratorRequestT& request,
                                           const RegisterDelegatedAdministratorResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::RegisterDelegatedAdministrator, request, handler, context);
  }
 
  virtual Model::RemoveAccountFromOrganizationOutcome RemoveAccountFromOrganization(
      const Model::RemoveAccountFromOrganizationRequest& request) const;
 
  template <typename RemoveAccountFromOrganizationRequestT = Model::RemoveAccountFromOrganizationRequest>
  Model::RemoveAccountFromOrganizationOutcomeCallable RemoveAccountFromOrganizationCallable(
      const RemoveAccountFromOrganizationRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::RemoveAccountFromOrganization, request);
  }
 
  template <typename RemoveAccountFromOrganizationRequestT = Model::RemoveAccountFromOrganizationRequest>
  void RemoveAccountFromOrganizationAsync(const RemoveAccountFromOrganizationRequestT& request,
                                          const RemoveAccountFromOrganizationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::RemoveAccountFromOrganization, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::TagResource, request, handler, context);
  }
 
  virtual Model::TerminateResponsibilityTransferOutcome TerminateResponsibilityTransfer(
      const Model::TerminateResponsibilityTransferRequest& request) const;
 
  template <typename TerminateResponsibilityTransferRequestT = Model::TerminateResponsibilityTransferRequest>
  Model::TerminateResponsibilityTransferOutcomeCallable TerminateResponsibilityTransferCallable(
      const TerminateResponsibilityTransferRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::TerminateResponsibilityTransfer, request);
  }
 
  template <typename TerminateResponsibilityTransferRequestT = Model::TerminateResponsibilityTransferRequest>
  void TerminateResponsibilityTransferAsync(const TerminateResponsibilityTransferRequestT& request,
                                            const TerminateResponsibilityTransferResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::TerminateResponsibilityTransfer, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateOrganizationalUnitOutcome UpdateOrganizationalUnit(const Model::UpdateOrganizationalUnitRequest& request) const;
 
  template <typename UpdateOrganizationalUnitRequestT = Model::UpdateOrganizationalUnitRequest>
  Model::UpdateOrganizationalUnitOutcomeCallable UpdateOrganizationalUnitCallable(const UpdateOrganizationalUnitRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::UpdateOrganizationalUnit, request);
  }
 
  template <typename UpdateOrganizationalUnitRequestT = Model::UpdateOrganizationalUnitRequest>
  void UpdateOrganizationalUnitAsync(const UpdateOrganizationalUnitRequestT& request,
                                     const UpdateOrganizationalUnitResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::UpdateOrganizationalUnit, request, handler, context);
  }
 
  virtual Model::UpdatePolicyOutcome UpdatePolicy(const Model::UpdatePolicyRequest& request) const;
 
  template <typename UpdatePolicyRequestT = Model::UpdatePolicyRequest>
  Model::UpdatePolicyOutcomeCallable UpdatePolicyCallable(const UpdatePolicyRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::UpdatePolicy, request);
  }
 
  template <typename UpdatePolicyRequestT = Model::UpdatePolicyRequest>
  void UpdatePolicyAsync(const UpdatePolicyRequestT& request, const UpdatePolicyResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::UpdatePolicy, request, handler, context);
  }
 
  virtual Model::UpdateResponsibilityTransferOutcome UpdateResponsibilityTransfer(
      const Model::UpdateResponsibilityTransferRequest& request) const;
 
  template <typename UpdateResponsibilityTransferRequestT = Model::UpdateResponsibilityTransferRequest>
  Model::UpdateResponsibilityTransferOutcomeCallable UpdateResponsibilityTransferCallable(
      const UpdateResponsibilityTransferRequestT& request) const {
    return SubmitCallable(&OrganizationsClient::UpdateResponsibilityTransfer, request);
  }
 
  template <typename UpdateResponsibilityTransferRequestT = Model::UpdateResponsibilityTransferRequest>
  void UpdateResponsibilityTransferAsync(const UpdateResponsibilityTransferRequestT& request,
                                         const UpdateResponsibilityTransferResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OrganizationsClient::UpdateResponsibilityTransfer, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<OrganizationsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<OrganizationsClient>;
  void init(const OrganizationsClientConfiguration& clientConfiguration);
 
  OrganizationsClientConfiguration m_clientConfiguration;
  std::shared_ptr<OrganizationsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Organizations
}  // namespace Aws