Route53DomainsClient.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/route53domains/Route53DomainsPaginationBase.h>
#include <aws/route53domains/Route53DomainsServiceClientModel.h>
#include <aws/route53domains/Route53DomainsWaiter.h>
#include <aws/route53domains/Route53Domains_EXPORTS.h>
 
namespace Aws {
namespace Route53Domains {
class AWS_ROUTE53DOMAINS_API Route53DomainsClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<Route53DomainsClient>,
                                                    public Route53DomainsPaginationBase<Route53DomainsClient>,
                                                    public Route53DomainsWaiter<Route53DomainsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef Route53DomainsClientConfiguration ClientConfigurationType;
  typedef Route53DomainsEndpointProvider EndpointProviderType;
 
  Route53DomainsClient(const Aws::Route53Domains::Route53DomainsClientConfiguration& clientConfiguration =
                           Aws::Route53Domains::Route53DomainsClientConfiguration(),
                       std::shared_ptr<Route53DomainsEndpointProviderBase> endpointProvider = nullptr);
 
  Route53DomainsClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<Route53DomainsEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Route53Domains::Route53DomainsClientConfiguration& clientConfiguration =
                           Aws::Route53Domains::Route53DomainsClientConfiguration());
 
  Route53DomainsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<Route53DomainsEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Route53Domains::Route53DomainsClientConfiguration& clientConfiguration =
                           Aws::Route53Domains::Route53DomainsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  Route53DomainsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Route53DomainsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Route53DomainsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~Route53DomainsClient();
 
  virtual Model::AcceptDomainTransferFromAnotherAwsAccountOutcome AcceptDomainTransferFromAnotherAwsAccount(
      const Model::AcceptDomainTransferFromAnotherAwsAccountRequest& request) const;
 
  template <typename AcceptDomainTransferFromAnotherAwsAccountRequestT = Model::AcceptDomainTransferFromAnotherAwsAccountRequest>
  Model::AcceptDomainTransferFromAnotherAwsAccountOutcomeCallable AcceptDomainTransferFromAnotherAwsAccountCallable(
      const AcceptDomainTransferFromAnotherAwsAccountRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::AcceptDomainTransferFromAnotherAwsAccount, request);
  }
 
  template <typename AcceptDomainTransferFromAnotherAwsAccountRequestT = Model::AcceptDomainTransferFromAnotherAwsAccountRequest>
  void AcceptDomainTransferFromAnotherAwsAccountAsync(
      const AcceptDomainTransferFromAnotherAwsAccountRequestT& request,
      const AcceptDomainTransferFromAnotherAwsAccountResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::AcceptDomainTransferFromAnotherAwsAccount, request, handler, context);
  }
 
  virtual Model::AssociateDelegationSignerToDomainOutcome AssociateDelegationSignerToDomain(
      const Model::AssociateDelegationSignerToDomainRequest& request) const;
 
  template <typename AssociateDelegationSignerToDomainRequestT = Model::AssociateDelegationSignerToDomainRequest>
  Model::AssociateDelegationSignerToDomainOutcomeCallable AssociateDelegationSignerToDomainCallable(
      const AssociateDelegationSignerToDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::AssociateDelegationSignerToDomain, request);
  }
 
  template <typename AssociateDelegationSignerToDomainRequestT = Model::AssociateDelegationSignerToDomainRequest>
  void AssociateDelegationSignerToDomainAsync(const AssociateDelegationSignerToDomainRequestT& request,
                                              const AssociateDelegationSignerToDomainResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::AssociateDelegationSignerToDomain, request, handler, context);
  }
 
  virtual Model::CancelDomainTransferToAnotherAwsAccountOutcome CancelDomainTransferToAnotherAwsAccount(
      const Model::CancelDomainTransferToAnotherAwsAccountRequest& request) const;
 
  template <typename CancelDomainTransferToAnotherAwsAccountRequestT = Model::CancelDomainTransferToAnotherAwsAccountRequest>
  Model::CancelDomainTransferToAnotherAwsAccountOutcomeCallable CancelDomainTransferToAnotherAwsAccountCallable(
      const CancelDomainTransferToAnotherAwsAccountRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::CancelDomainTransferToAnotherAwsAccount, request);
  }
 
  template <typename CancelDomainTransferToAnotherAwsAccountRequestT = Model::CancelDomainTransferToAnotherAwsAccountRequest>
  void CancelDomainTransferToAnotherAwsAccountAsync(const CancelDomainTransferToAnotherAwsAccountRequestT& request,
                                                    const CancelDomainTransferToAnotherAwsAccountResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::CancelDomainTransferToAnotherAwsAccount, request, handler, context);
  }
 
  virtual Model::CheckDomainAvailabilityOutcome CheckDomainAvailability(const Model::CheckDomainAvailabilityRequest& request) const;
 
  template <typename CheckDomainAvailabilityRequestT = Model::CheckDomainAvailabilityRequest>
  Model::CheckDomainAvailabilityOutcomeCallable CheckDomainAvailabilityCallable(const CheckDomainAvailabilityRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::CheckDomainAvailability, request);
  }
 
  template <typename CheckDomainAvailabilityRequestT = Model::CheckDomainAvailabilityRequest>
  void CheckDomainAvailabilityAsync(const CheckDomainAvailabilityRequestT& request,
                                    const CheckDomainAvailabilityResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::CheckDomainAvailability, request, handler, context);
  }
 
  virtual Model::CheckDomainTransferabilityOutcome CheckDomainTransferability(
      const Model::CheckDomainTransferabilityRequest& request) const;
 
  template <typename CheckDomainTransferabilityRequestT = Model::CheckDomainTransferabilityRequest>
  Model::CheckDomainTransferabilityOutcomeCallable CheckDomainTransferabilityCallable(
      const CheckDomainTransferabilityRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::CheckDomainTransferability, request);
  }
 
  template <typename CheckDomainTransferabilityRequestT = Model::CheckDomainTransferabilityRequest>
  void CheckDomainTransferabilityAsync(const CheckDomainTransferabilityRequestT& request,
                                       const CheckDomainTransferabilityResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::CheckDomainTransferability, request, handler, context);
  }
 
  virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::DeleteDomain, request);
  }
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteTagsForDomainOutcome DeleteTagsForDomain(const Model::DeleteTagsForDomainRequest& request) const;
 
  template <typename DeleteTagsForDomainRequestT = Model::DeleteTagsForDomainRequest>
  Model::DeleteTagsForDomainOutcomeCallable DeleteTagsForDomainCallable(const DeleteTagsForDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::DeleteTagsForDomain, request);
  }
 
  template <typename DeleteTagsForDomainRequestT = Model::DeleteTagsForDomainRequest>
  void DeleteTagsForDomainAsync(const DeleteTagsForDomainRequestT& request, const DeleteTagsForDomainResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::DeleteTagsForDomain, request, handler, context);
  }
 
  virtual Model::DisableDomainAutoRenewOutcome DisableDomainAutoRenew(const Model::DisableDomainAutoRenewRequest& request) const;
 
  template <typename DisableDomainAutoRenewRequestT = Model::DisableDomainAutoRenewRequest>
  Model::DisableDomainAutoRenewOutcomeCallable DisableDomainAutoRenewCallable(const DisableDomainAutoRenewRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::DisableDomainAutoRenew, request);
  }
 
  template <typename DisableDomainAutoRenewRequestT = Model::DisableDomainAutoRenewRequest>
  void DisableDomainAutoRenewAsync(const DisableDomainAutoRenewRequestT& request,
                                   const DisableDomainAutoRenewResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::DisableDomainAutoRenew, request, handler, context);
  }
 
  virtual Model::DisableDomainTransferLockOutcome DisableDomainTransferLock(const Model::DisableDomainTransferLockRequest& request) const;
 
  template <typename DisableDomainTransferLockRequestT = Model::DisableDomainTransferLockRequest>
  Model::DisableDomainTransferLockOutcomeCallable DisableDomainTransferLockCallable(
      const DisableDomainTransferLockRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::DisableDomainTransferLock, request);
  }
 
  template <typename DisableDomainTransferLockRequestT = Model::DisableDomainTransferLockRequest>
  void DisableDomainTransferLockAsync(const DisableDomainTransferLockRequestT& request,
                                      const DisableDomainTransferLockResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::DisableDomainTransferLock, request, handler, context);
  }
 
  virtual Model::DisassociateDelegationSignerFromDomainOutcome DisassociateDelegationSignerFromDomain(
      const Model::DisassociateDelegationSignerFromDomainRequest& request) const;
 
  template <typename DisassociateDelegationSignerFromDomainRequestT = Model::DisassociateDelegationSignerFromDomainRequest>
  Model::DisassociateDelegationSignerFromDomainOutcomeCallable DisassociateDelegationSignerFromDomainCallable(
      const DisassociateDelegationSignerFromDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::DisassociateDelegationSignerFromDomain, request);
  }
 
  template <typename DisassociateDelegationSignerFromDomainRequestT = Model::DisassociateDelegationSignerFromDomainRequest>
  void DisassociateDelegationSignerFromDomainAsync(const DisassociateDelegationSignerFromDomainRequestT& request,
                                                   const DisassociateDelegationSignerFromDomainResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::DisassociateDelegationSignerFromDomain, request, handler, context);
  }
 
  virtual Model::EnableDomainAutoRenewOutcome EnableDomainAutoRenew(const Model::EnableDomainAutoRenewRequest& request) const;
 
  template <typename EnableDomainAutoRenewRequestT = Model::EnableDomainAutoRenewRequest>
  Model::EnableDomainAutoRenewOutcomeCallable EnableDomainAutoRenewCallable(const EnableDomainAutoRenewRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::EnableDomainAutoRenew, request);
  }
 
  template <typename EnableDomainAutoRenewRequestT = Model::EnableDomainAutoRenewRequest>
  void EnableDomainAutoRenewAsync(const EnableDomainAutoRenewRequestT& request, const EnableDomainAutoRenewResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::EnableDomainAutoRenew, request, handler, context);
  }
 
  virtual Model::EnableDomainTransferLockOutcome EnableDomainTransferLock(const Model::EnableDomainTransferLockRequest& request) const;
 
  template <typename EnableDomainTransferLockRequestT = Model::EnableDomainTransferLockRequest>
  Model::EnableDomainTransferLockOutcomeCallable EnableDomainTransferLockCallable(const EnableDomainTransferLockRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::EnableDomainTransferLock, request);
  }
 
  template <typename EnableDomainTransferLockRequestT = Model::EnableDomainTransferLockRequest>
  void EnableDomainTransferLockAsync(const EnableDomainTransferLockRequestT& request,
                                     const EnableDomainTransferLockResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::EnableDomainTransferLock, request, handler, context);
  }
 
  virtual Model::GetContactReachabilityStatusOutcome GetContactReachabilityStatus(
      const Model::GetContactReachabilityStatusRequest& request = {}) const;
 
  template <typename GetContactReachabilityStatusRequestT = Model::GetContactReachabilityStatusRequest>
  Model::GetContactReachabilityStatusOutcomeCallable GetContactReachabilityStatusCallable(
      const GetContactReachabilityStatusRequestT& request = {}) const {
    return SubmitCallable(&Route53DomainsClient::GetContactReachabilityStatus, request);
  }
 
  template <typename GetContactReachabilityStatusRequestT = Model::GetContactReachabilityStatusRequest>
  void GetContactReachabilityStatusAsync(const GetContactReachabilityStatusResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetContactReachabilityStatusRequestT& request = {}) const {
    return SubmitAsync(&Route53DomainsClient::GetContactReachabilityStatus, request, handler, context);
  }
 
  virtual Model::GetDomainDetailOutcome GetDomainDetail(const Model::GetDomainDetailRequest& request) const;
 
  template <typename GetDomainDetailRequestT = Model::GetDomainDetailRequest>
  Model::GetDomainDetailOutcomeCallable GetDomainDetailCallable(const GetDomainDetailRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::GetDomainDetail, request);
  }
 
  template <typename GetDomainDetailRequestT = Model::GetDomainDetailRequest>
  void GetDomainDetailAsync(const GetDomainDetailRequestT& request, const GetDomainDetailResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::GetDomainDetail, request, handler, context);
  }
 
  virtual Model::GetDomainSuggestionsOutcome GetDomainSuggestions(const Model::GetDomainSuggestionsRequest& request) const;
 
  template <typename GetDomainSuggestionsRequestT = Model::GetDomainSuggestionsRequest>
  Model::GetDomainSuggestionsOutcomeCallable GetDomainSuggestionsCallable(const GetDomainSuggestionsRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::GetDomainSuggestions, request);
  }
 
  template <typename GetDomainSuggestionsRequestT = Model::GetDomainSuggestionsRequest>
  void GetDomainSuggestionsAsync(const GetDomainSuggestionsRequestT& request, const GetDomainSuggestionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::GetDomainSuggestions, request, handler, context);
  }
 
  virtual Model::GetOperationDetailOutcome GetOperationDetail(const Model::GetOperationDetailRequest& request) const;
 
  template <typename GetOperationDetailRequestT = Model::GetOperationDetailRequest>
  Model::GetOperationDetailOutcomeCallable GetOperationDetailCallable(const GetOperationDetailRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::GetOperationDetail, request);
  }
 
  template <typename GetOperationDetailRequestT = Model::GetOperationDetailRequest>
  void GetOperationDetailAsync(const GetOperationDetailRequestT& request, const GetOperationDetailResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::GetOperationDetail, request, handler, context);
  }
 
  virtual Model::ListDomainsOutcome ListDomains(const Model::ListDomainsRequest& request = {}) const;
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  Model::ListDomainsOutcomeCallable ListDomainsCallable(const ListDomainsRequestT& request = {}) const {
    return SubmitCallable(&Route53DomainsClient::ListDomains, request);
  }
 
  template <typename ListDomainsRequestT = Model::ListDomainsRequest>
  void ListDomainsAsync(const ListDomainsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListDomainsRequestT& request = {}) const {
    return SubmitAsync(&Route53DomainsClient::ListDomains, request, handler, context);
  }
 
  virtual Model::ListOperationsOutcome ListOperations(const Model::ListOperationsRequest& request = {}) const;
 
  template <typename ListOperationsRequestT = Model::ListOperationsRequest>
  Model::ListOperationsOutcomeCallable ListOperationsCallable(const ListOperationsRequestT& request = {}) const {
    return SubmitCallable(&Route53DomainsClient::ListOperations, request);
  }
 
  template <typename ListOperationsRequestT = Model::ListOperationsRequest>
  void ListOperationsAsync(const ListOperationsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListOperationsRequestT& request = {}) const {
    return SubmitAsync(&Route53DomainsClient::ListOperations, request, handler, context);
  }
 
  virtual Model::ListPricesOutcome ListPrices(const Model::ListPricesRequest& request = {}) const;
 
  template <typename ListPricesRequestT = Model::ListPricesRequest>
  Model::ListPricesOutcomeCallable ListPricesCallable(const ListPricesRequestT& request = {}) const {
    return SubmitCallable(&Route53DomainsClient::ListPrices, request);
  }
 
  template <typename ListPricesRequestT = Model::ListPricesRequest>
  void ListPricesAsync(const ListPricesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListPricesRequestT& request = {}) const {
    return SubmitAsync(&Route53DomainsClient::ListPrices, request, handler, context);
  }
 
  virtual Model::ListTagsForDomainOutcome ListTagsForDomain(const Model::ListTagsForDomainRequest& request) const;
 
  template <typename ListTagsForDomainRequestT = Model::ListTagsForDomainRequest>
  Model::ListTagsForDomainOutcomeCallable ListTagsForDomainCallable(const ListTagsForDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::ListTagsForDomain, request);
  }
 
  template <typename ListTagsForDomainRequestT = Model::ListTagsForDomainRequest>
  void ListTagsForDomainAsync(const ListTagsForDomainRequestT& request, const ListTagsForDomainResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::ListTagsForDomain, request, handler, context);
  }
 
  virtual Model::PushDomainOutcome PushDomain(const Model::PushDomainRequest& request) const;
 
  template <typename PushDomainRequestT = Model::PushDomainRequest>
  Model::PushDomainOutcomeCallable PushDomainCallable(const PushDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::PushDomain, request);
  }
 
  template <typename PushDomainRequestT = Model::PushDomainRequest>
  void PushDomainAsync(const PushDomainRequestT& request, const PushDomainResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::PushDomain, request, handler, context);
  }
 
  virtual Model::RegisterDomainOutcome RegisterDomain(const Model::RegisterDomainRequest& request) const;
 
  template <typename RegisterDomainRequestT = Model::RegisterDomainRequest>
  Model::RegisterDomainOutcomeCallable RegisterDomainCallable(const RegisterDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::RegisterDomain, request);
  }
 
  template <typename RegisterDomainRequestT = Model::RegisterDomainRequest>
  void RegisterDomainAsync(const RegisterDomainRequestT& request, const RegisterDomainResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::RegisterDomain, request, handler, context);
  }
 
  virtual Model::RejectDomainTransferFromAnotherAwsAccountOutcome RejectDomainTransferFromAnotherAwsAccount(
      const Model::RejectDomainTransferFromAnotherAwsAccountRequest& request) const;
 
  template <typename RejectDomainTransferFromAnotherAwsAccountRequestT = Model::RejectDomainTransferFromAnotherAwsAccountRequest>
  Model::RejectDomainTransferFromAnotherAwsAccountOutcomeCallable RejectDomainTransferFromAnotherAwsAccountCallable(
      const RejectDomainTransferFromAnotherAwsAccountRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::RejectDomainTransferFromAnotherAwsAccount, request);
  }
 
  template <typename RejectDomainTransferFromAnotherAwsAccountRequestT = Model::RejectDomainTransferFromAnotherAwsAccountRequest>
  void RejectDomainTransferFromAnotherAwsAccountAsync(
      const RejectDomainTransferFromAnotherAwsAccountRequestT& request,
      const RejectDomainTransferFromAnotherAwsAccountResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::RejectDomainTransferFromAnotherAwsAccount, request, handler, context);
  }
 
  virtual Model::RenewDomainOutcome RenewDomain(const Model::RenewDomainRequest& request) const;
 
  template <typename RenewDomainRequestT = Model::RenewDomainRequest>
  Model::RenewDomainOutcomeCallable RenewDomainCallable(const RenewDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::RenewDomain, request);
  }
 
  template <typename RenewDomainRequestT = Model::RenewDomainRequest>
  void RenewDomainAsync(const RenewDomainRequestT& request, const RenewDomainResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::RenewDomain, request, handler, context);
  }
 
  virtual Model::ResendContactReachabilityEmailOutcome ResendContactReachabilityEmail(
      const Model::ResendContactReachabilityEmailRequest& request = {}) const;
 
  template <typename ResendContactReachabilityEmailRequestT = Model::ResendContactReachabilityEmailRequest>
  Model::ResendContactReachabilityEmailOutcomeCallable ResendContactReachabilityEmailCallable(
      const ResendContactReachabilityEmailRequestT& request = {}) const {
    return SubmitCallable(&Route53DomainsClient::ResendContactReachabilityEmail, request);
  }
 
  template <typename ResendContactReachabilityEmailRequestT = Model::ResendContactReachabilityEmailRequest>
  void ResendContactReachabilityEmailAsync(const ResendContactReachabilityEmailResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ResendContactReachabilityEmailRequestT& request = {}) const {
    return SubmitAsync(&Route53DomainsClient::ResendContactReachabilityEmail, request, handler, context);
  }
 
  virtual Model::ResendOperationAuthorizationOutcome ResendOperationAuthorization(
      const Model::ResendOperationAuthorizationRequest& request) const;
 
  template <typename ResendOperationAuthorizationRequestT = Model::ResendOperationAuthorizationRequest>
  Model::ResendOperationAuthorizationOutcomeCallable ResendOperationAuthorizationCallable(
      const ResendOperationAuthorizationRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::ResendOperationAuthorization, request);
  }
 
  template <typename ResendOperationAuthorizationRequestT = Model::ResendOperationAuthorizationRequest>
  void ResendOperationAuthorizationAsync(const ResendOperationAuthorizationRequestT& request,
                                         const ResendOperationAuthorizationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::ResendOperationAuthorization, request, handler, context);
  }
 
  virtual Model::RetrieveDomainAuthCodeOutcome RetrieveDomainAuthCode(const Model::RetrieveDomainAuthCodeRequest& request) const;
 
  template <typename RetrieveDomainAuthCodeRequestT = Model::RetrieveDomainAuthCodeRequest>
  Model::RetrieveDomainAuthCodeOutcomeCallable RetrieveDomainAuthCodeCallable(const RetrieveDomainAuthCodeRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::RetrieveDomainAuthCode, request);
  }
 
  template <typename RetrieveDomainAuthCodeRequestT = Model::RetrieveDomainAuthCodeRequest>
  void RetrieveDomainAuthCodeAsync(const RetrieveDomainAuthCodeRequestT& request,
                                   const RetrieveDomainAuthCodeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::RetrieveDomainAuthCode, request, handler, context);
  }
 
  virtual Model::TransferDomainOutcome TransferDomain(const Model::TransferDomainRequest& request) const;
 
  template <typename TransferDomainRequestT = Model::TransferDomainRequest>
  Model::TransferDomainOutcomeCallable TransferDomainCallable(const TransferDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::TransferDomain, request);
  }
 
  template <typename TransferDomainRequestT = Model::TransferDomainRequest>
  void TransferDomainAsync(const TransferDomainRequestT& request, const TransferDomainResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::TransferDomain, request, handler, context);
  }
 
  virtual Model::TransferDomainToAnotherAwsAccountOutcome TransferDomainToAnotherAwsAccount(
      const Model::TransferDomainToAnotherAwsAccountRequest& request) const;
 
  template <typename TransferDomainToAnotherAwsAccountRequestT = Model::TransferDomainToAnotherAwsAccountRequest>
  Model::TransferDomainToAnotherAwsAccountOutcomeCallable TransferDomainToAnotherAwsAccountCallable(
      const TransferDomainToAnotherAwsAccountRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::TransferDomainToAnotherAwsAccount, request);
  }
 
  template <typename TransferDomainToAnotherAwsAccountRequestT = Model::TransferDomainToAnotherAwsAccountRequest>
  void TransferDomainToAnotherAwsAccountAsync(const TransferDomainToAnotherAwsAccountRequestT& request,
                                              const TransferDomainToAnotherAwsAccountResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::TransferDomainToAnotherAwsAccount, request, handler, context);
  }
 
  virtual Model::UpdateDomainContactOutcome UpdateDomainContact(const Model::UpdateDomainContactRequest& request) const;
 
  template <typename UpdateDomainContactRequestT = Model::UpdateDomainContactRequest>
  Model::UpdateDomainContactOutcomeCallable UpdateDomainContactCallable(const UpdateDomainContactRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::UpdateDomainContact, request);
  }
 
  template <typename UpdateDomainContactRequestT = Model::UpdateDomainContactRequest>
  void UpdateDomainContactAsync(const UpdateDomainContactRequestT& request, const UpdateDomainContactResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::UpdateDomainContact, request, handler, context);
  }
 
  virtual Model::UpdateDomainContactPrivacyOutcome UpdateDomainContactPrivacy(
      const Model::UpdateDomainContactPrivacyRequest& request) const;
 
  template <typename UpdateDomainContactPrivacyRequestT = Model::UpdateDomainContactPrivacyRequest>
  Model::UpdateDomainContactPrivacyOutcomeCallable UpdateDomainContactPrivacyCallable(
      const UpdateDomainContactPrivacyRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::UpdateDomainContactPrivacy, request);
  }
 
  template <typename UpdateDomainContactPrivacyRequestT = Model::UpdateDomainContactPrivacyRequest>
  void UpdateDomainContactPrivacyAsync(const UpdateDomainContactPrivacyRequestT& request,
                                       const UpdateDomainContactPrivacyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::UpdateDomainContactPrivacy, request, handler, context);
  }
 
  virtual Model::UpdateDomainNameserversOutcome UpdateDomainNameservers(const Model::UpdateDomainNameserversRequest& request) const;
 
  template <typename UpdateDomainNameserversRequestT = Model::UpdateDomainNameserversRequest>
  Model::UpdateDomainNameserversOutcomeCallable UpdateDomainNameserversCallable(const UpdateDomainNameserversRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::UpdateDomainNameservers, request);
  }
 
  template <typename UpdateDomainNameserversRequestT = Model::UpdateDomainNameserversRequest>
  void UpdateDomainNameserversAsync(const UpdateDomainNameserversRequestT& request,
                                    const UpdateDomainNameserversResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::UpdateDomainNameservers, request, handler, context);
  }
 
  virtual Model::UpdateTagsForDomainOutcome UpdateTagsForDomain(const Model::UpdateTagsForDomainRequest& request) const;
 
  template <typename UpdateTagsForDomainRequestT = Model::UpdateTagsForDomainRequest>
  Model::UpdateTagsForDomainOutcomeCallable UpdateTagsForDomainCallable(const UpdateTagsForDomainRequestT& request) const {
    return SubmitCallable(&Route53DomainsClient::UpdateTagsForDomain, request);
  }
 
  template <typename UpdateTagsForDomainRequestT = Model::UpdateTagsForDomainRequest>
  void UpdateTagsForDomainAsync(const UpdateTagsForDomainRequestT& request, const UpdateTagsForDomainResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53DomainsClient::UpdateTagsForDomain, request, handler, context);
  }
 
  virtual Model::ViewBillingOutcome ViewBilling(const Model::ViewBillingRequest& request = {}) const;
 
  template <typename ViewBillingRequestT = Model::ViewBillingRequest>
  Model::ViewBillingOutcomeCallable ViewBillingCallable(const ViewBillingRequestT& request = {}) const {
    return SubmitCallable(&Route53DomainsClient::ViewBilling, request);
  }
 
  template <typename ViewBillingRequestT = Model::ViewBillingRequest>
  void ViewBillingAsync(const ViewBillingResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ViewBillingRequestT& request = {}) const {
    return SubmitAsync(&Route53DomainsClient::ViewBilling, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Route53DomainsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53DomainsClient>;
  void init(const Route53DomainsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, Route53DomainsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  Route53DomainsClientConfiguration m_clientConfiguration;
  std::shared_ptr<Route53DomainsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Route53Domains
}  // namespace Aws