OrganizationsClient.h

 
#pragma once
#include <aws/organizations/Organizations_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/organizations/OrganizationsServiceClientModel.h>
 
namespace Aws
{
namespace Organizations
{
  class AWS_ORGANIZATIONS_API OrganizationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      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