AccountClient.h

 
#pragma once
#include <aws/account/Account_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/account/AccountServiceClientModel.h>
 
namespace Aws
{
namespace Account
{
  class AWS_ACCOUNT_API AccountClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AccountClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AccountClientConfiguration ClientConfigurationType;
      typedef AccountEndpointProvider EndpointProviderType;
 
        AccountClient(const Aws::Account::AccountClientConfiguration& clientConfiguration = Aws::Account::AccountClientConfiguration(),
                      std::shared_ptr<AccountEndpointProviderBase> endpointProvider = nullptr);
 
        AccountClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<AccountEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Account::AccountClientConfiguration& clientConfiguration = Aws::Account::AccountClientConfiguration());
 
        AccountClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<AccountEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Account::AccountClientConfiguration& clientConfiguration = Aws::Account::AccountClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AccountClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AccountClient(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AccountClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AccountClient();
 
        virtual Model::AcceptPrimaryEmailUpdateOutcome AcceptPrimaryEmailUpdate(const Model::AcceptPrimaryEmailUpdateRequest& request) const;
 
        template<typename AcceptPrimaryEmailUpdateRequestT = Model::AcceptPrimaryEmailUpdateRequest>
        Model::AcceptPrimaryEmailUpdateOutcomeCallable AcceptPrimaryEmailUpdateCallable(const AcceptPrimaryEmailUpdateRequestT& request) const
        {
            return SubmitCallable(&AccountClient::AcceptPrimaryEmailUpdate, request);
        }
 
        template<typename AcceptPrimaryEmailUpdateRequestT = Model::AcceptPrimaryEmailUpdateRequest>
        void AcceptPrimaryEmailUpdateAsync(const AcceptPrimaryEmailUpdateRequestT& request, const AcceptPrimaryEmailUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::AcceptPrimaryEmailUpdate, request, handler, context);
        }
 
        virtual Model::DeleteAlternateContactOutcome DeleteAlternateContact(const Model::DeleteAlternateContactRequest& request) const;
 
        template<typename DeleteAlternateContactRequestT = Model::DeleteAlternateContactRequest>
        Model::DeleteAlternateContactOutcomeCallable DeleteAlternateContactCallable(const DeleteAlternateContactRequestT& request) const
        {
            return SubmitCallable(&AccountClient::DeleteAlternateContact, request);
        }
 
        template<typename DeleteAlternateContactRequestT = Model::DeleteAlternateContactRequest>
        void DeleteAlternateContactAsync(const DeleteAlternateContactRequestT& request, const DeleteAlternateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::DeleteAlternateContact, request, handler, context);
        }
 
        virtual Model::DisableRegionOutcome DisableRegion(const Model::DisableRegionRequest& request) const;
 
        template<typename DisableRegionRequestT = Model::DisableRegionRequest>
        Model::DisableRegionOutcomeCallable DisableRegionCallable(const DisableRegionRequestT& request) const
        {
            return SubmitCallable(&AccountClient::DisableRegion, request);
        }
 
        template<typename DisableRegionRequestT = Model::DisableRegionRequest>
        void DisableRegionAsync(const DisableRegionRequestT& request, const DisableRegionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::DisableRegion, request, handler, context);
        }
 
        virtual Model::EnableRegionOutcome EnableRegion(const Model::EnableRegionRequest& request) const;
 
        template<typename EnableRegionRequestT = Model::EnableRegionRequest>
        Model::EnableRegionOutcomeCallable EnableRegionCallable(const EnableRegionRequestT& request) const
        {
            return SubmitCallable(&AccountClient::EnableRegion, request);
        }
 
        template<typename EnableRegionRequestT = Model::EnableRegionRequest>
        void EnableRegionAsync(const EnableRegionRequestT& request, const EnableRegionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::EnableRegion, request, handler, context);
        }
 
        virtual Model::GetAccountInformationOutcome GetAccountInformation(const Model::GetAccountInformationRequest& request = {}) const;
 
        template<typename GetAccountInformationRequestT = Model::GetAccountInformationRequest>
        Model::GetAccountInformationOutcomeCallable GetAccountInformationCallable(const GetAccountInformationRequestT& request = {}) const
        {
            return SubmitCallable(&AccountClient::GetAccountInformation, request);
        }
 
        template<typename GetAccountInformationRequestT = Model::GetAccountInformationRequest>
        void GetAccountInformationAsync(const GetAccountInformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountInformationRequestT& request = {}) const
        {
            return SubmitAsync(&AccountClient::GetAccountInformation, request, handler, context);
        }
 
        virtual Model::GetAlternateContactOutcome GetAlternateContact(const Model::GetAlternateContactRequest& request) const;
 
        template<typename GetAlternateContactRequestT = Model::GetAlternateContactRequest>
        Model::GetAlternateContactOutcomeCallable GetAlternateContactCallable(const GetAlternateContactRequestT& request) const
        {
            return SubmitCallable(&AccountClient::GetAlternateContact, request);
        }
 
        template<typename GetAlternateContactRequestT = Model::GetAlternateContactRequest>
        void GetAlternateContactAsync(const GetAlternateContactRequestT& request, const GetAlternateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::GetAlternateContact, request, handler, context);
        }
 
        virtual Model::GetContactInformationOutcome GetContactInformation(const Model::GetContactInformationRequest& request = {}) const;
 
        template<typename GetContactInformationRequestT = Model::GetContactInformationRequest>
        Model::GetContactInformationOutcomeCallable GetContactInformationCallable(const GetContactInformationRequestT& request = {}) const
        {
            return SubmitCallable(&AccountClient::GetContactInformation, request);
        }
 
        template<typename GetContactInformationRequestT = Model::GetContactInformationRequest>
        void GetContactInformationAsync(const GetContactInformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetContactInformationRequestT& request = {}) const
        {
            return SubmitAsync(&AccountClient::GetContactInformation, request, handler, context);
        }
 
        virtual Model::GetPrimaryEmailOutcome GetPrimaryEmail(const Model::GetPrimaryEmailRequest& request) const;
 
        template<typename GetPrimaryEmailRequestT = Model::GetPrimaryEmailRequest>
        Model::GetPrimaryEmailOutcomeCallable GetPrimaryEmailCallable(const GetPrimaryEmailRequestT& request) const
        {
            return SubmitCallable(&AccountClient::GetPrimaryEmail, request);
        }
 
        template<typename GetPrimaryEmailRequestT = Model::GetPrimaryEmailRequest>
        void GetPrimaryEmailAsync(const GetPrimaryEmailRequestT& request, const GetPrimaryEmailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::GetPrimaryEmail, request, handler, context);
        }
 
        virtual Model::GetRegionOptStatusOutcome GetRegionOptStatus(const Model::GetRegionOptStatusRequest& request) const;
 
        template<typename GetRegionOptStatusRequestT = Model::GetRegionOptStatusRequest>
        Model::GetRegionOptStatusOutcomeCallable GetRegionOptStatusCallable(const GetRegionOptStatusRequestT& request) const
        {
            return SubmitCallable(&AccountClient::GetRegionOptStatus, request);
        }
 
        template<typename GetRegionOptStatusRequestT = Model::GetRegionOptStatusRequest>
        void GetRegionOptStatusAsync(const GetRegionOptStatusRequestT& request, const GetRegionOptStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::GetRegionOptStatus, request, handler, context);
        }
 
        virtual Model::ListRegionsOutcome ListRegions(const Model::ListRegionsRequest& request = {}) const;
 
        template<typename ListRegionsRequestT = Model::ListRegionsRequest>
        Model::ListRegionsOutcomeCallable ListRegionsCallable(const ListRegionsRequestT& request = {}) const
        {
            return SubmitCallable(&AccountClient::ListRegions, request);
        }
 
        template<typename ListRegionsRequestT = Model::ListRegionsRequest>
        void ListRegionsAsync(const ListRegionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRegionsRequestT& request = {}) const
        {
            return SubmitAsync(&AccountClient::ListRegions, request, handler, context);
        }
 
        virtual Model::PutAccountNameOutcome PutAccountName(const Model::PutAccountNameRequest& request) const;
 
        template<typename PutAccountNameRequestT = Model::PutAccountNameRequest>
        Model::PutAccountNameOutcomeCallable PutAccountNameCallable(const PutAccountNameRequestT& request) const
        {
            return SubmitCallable(&AccountClient::PutAccountName, request);
        }
 
        template<typename PutAccountNameRequestT = Model::PutAccountNameRequest>
        void PutAccountNameAsync(const PutAccountNameRequestT& request, const PutAccountNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::PutAccountName, request, handler, context);
        }
 
        virtual Model::PutAlternateContactOutcome PutAlternateContact(const Model::PutAlternateContactRequest& request) const;
 
        template<typename PutAlternateContactRequestT = Model::PutAlternateContactRequest>
        Model::PutAlternateContactOutcomeCallable PutAlternateContactCallable(const PutAlternateContactRequestT& request) const
        {
            return SubmitCallable(&AccountClient::PutAlternateContact, request);
        }
 
        template<typename PutAlternateContactRequestT = Model::PutAlternateContactRequest>
        void PutAlternateContactAsync(const PutAlternateContactRequestT& request, const PutAlternateContactResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::PutAlternateContact, request, handler, context);
        }
 
        virtual Model::PutContactInformationOutcome PutContactInformation(const Model::PutContactInformationRequest& request) const;
 
        template<typename PutContactInformationRequestT = Model::PutContactInformationRequest>
        Model::PutContactInformationOutcomeCallable PutContactInformationCallable(const PutContactInformationRequestT& request) const
        {
            return SubmitCallable(&AccountClient::PutContactInformation, request);
        }
 
        template<typename PutContactInformationRequestT = Model::PutContactInformationRequest>
        void PutContactInformationAsync(const PutContactInformationRequestT& request, const PutContactInformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::PutContactInformation, request, handler, context);
        }
 
        virtual Model::StartPrimaryEmailUpdateOutcome StartPrimaryEmailUpdate(const Model::StartPrimaryEmailUpdateRequest& request) const;
 
        template<typename StartPrimaryEmailUpdateRequestT = Model::StartPrimaryEmailUpdateRequest>
        Model::StartPrimaryEmailUpdateOutcomeCallable StartPrimaryEmailUpdateCallable(const StartPrimaryEmailUpdateRequestT& request) const
        {
            return SubmitCallable(&AccountClient::StartPrimaryEmailUpdate, request);
        }
 
        template<typename StartPrimaryEmailUpdateRequestT = Model::StartPrimaryEmailUpdateRequest>
        void StartPrimaryEmailUpdateAsync(const StartPrimaryEmailUpdateRequestT& request, const StartPrimaryEmailUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AccountClient::StartPrimaryEmailUpdate, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AccountEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AccountClient>;
      void init(const AccountClientConfiguration& clientConfiguration);
 
      AccountClientConfiguration m_clientConfiguration;
      std::shared_ptr<AccountEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Account
} // namespace Aws