Route53DomainsClient.h

 
#pragma once
#include <aws/route53domains/Route53Domains_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/route53domains/Route53DomainsServiceClientModel.h>
 
namespace Aws
{
namespace Route53Domains
{
  class AWS_ROUTE53DOMAINS_API Route53DomainsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<Route53DomainsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53DomainsClient>;
      void init(const Route53DomainsClientConfiguration& clientConfiguration);
 
      Route53DomainsClientConfiguration m_clientConfiguration;
      std::shared_ptr<Route53DomainsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Route53Domains
} // namespace Aws