AccountClient.h

 
#pragma once
#include <aws/account/AccountPaginationBase.h>
#include <aws/account/AccountServiceClientModel.h>
#include <aws/account/AccountWaiter.h>
#include <aws/account/Account_EXPORTS.h>
#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>
 
namespace Aws {
namespace Account {
class AWS_ACCOUNT_API AccountClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<AccountClient>,
                                      public AccountPaginationBase<AccountClient>,
                                      public AccountWaiter<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::GetGovCloudAccountInformationOutcome GetGovCloudAccountInformation(
      const Model::GetGovCloudAccountInformationRequest& request = {}) const;
 
  template <typename GetGovCloudAccountInformationRequestT = Model::GetGovCloudAccountInformationRequest>
  Model::GetGovCloudAccountInformationOutcomeCallable GetGovCloudAccountInformationCallable(
      const GetGovCloudAccountInformationRequestT& request = {}) const {
    return SubmitCallable(&AccountClient::GetGovCloudAccountInformation, request);
  }
 
  template <typename GetGovCloudAccountInformationRequestT = Model::GetGovCloudAccountInformationRequest>
  void GetGovCloudAccountInformationAsync(const GetGovCloudAccountInformationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const GetGovCloudAccountInformationRequestT& request = {}) const {
    return SubmitAsync(&AccountClient::GetGovCloudAccountInformation, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AccountEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AccountClient>;
  void init(const AccountClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AccountError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AccountClientConfiguration m_clientConfiguration;
  std::shared_ptr<AccountEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Account
}  // namespace Aws