Route53Client.h

 
#pragma once
#include <aws/route53/Route53_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/route53/Route53ServiceClientModel.h>
 
namespace Aws
{
namespace Route53
{
  class AWS_ROUTE53_API Route53Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<Route53Client>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef Route53ClientConfiguration ClientConfigurationType;
      typedef Route53EndpointProvider EndpointProviderType;
 
        Route53Client(const Aws::Route53::Route53ClientConfiguration& clientConfiguration = Aws::Route53::Route53ClientConfiguration(),
                      std::shared_ptr<Route53EndpointProviderBase> endpointProvider = nullptr);
 
        Route53Client(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<Route53EndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Route53::Route53ClientConfiguration& clientConfiguration = Aws::Route53::Route53ClientConfiguration());
 
        Route53Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<Route53EndpointProviderBase> endpointProvider = nullptr,
                      const Aws::Route53::Route53ClientConfiguration& clientConfiguration = Aws::Route53::Route53ClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        Route53Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53Client(const Aws::Auth::AWSCredentials& credentials,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~Route53Client();
 
 
        virtual Model::ActivateKeySigningKeyOutcome ActivateKeySigningKey(const Model::ActivateKeySigningKeyRequest& request) const;
 
        template<typename ActivateKeySigningKeyRequestT = Model::ActivateKeySigningKeyRequest>
        Model::ActivateKeySigningKeyOutcomeCallable ActivateKeySigningKeyCallable(const ActivateKeySigningKeyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ActivateKeySigningKey, request);
        }
 
        template<typename ActivateKeySigningKeyRequestT = Model::ActivateKeySigningKeyRequest>
        void ActivateKeySigningKeyAsync(const ActivateKeySigningKeyRequestT& request, const ActivateKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ActivateKeySigningKey, request, handler, context);
        }
 
        virtual Model::AssociateVPCWithHostedZoneOutcome AssociateVPCWithHostedZone(const Model::AssociateVPCWithHostedZoneRequest& request) const;
 
        template<typename AssociateVPCWithHostedZoneRequestT = Model::AssociateVPCWithHostedZoneRequest>
        Model::AssociateVPCWithHostedZoneOutcomeCallable AssociateVPCWithHostedZoneCallable(const AssociateVPCWithHostedZoneRequestT& request) const
        {
            return SubmitCallable(&Route53Client::AssociateVPCWithHostedZone, request);
        }
 
        template<typename AssociateVPCWithHostedZoneRequestT = Model::AssociateVPCWithHostedZoneRequest>
        void AssociateVPCWithHostedZoneAsync(const AssociateVPCWithHostedZoneRequestT& request, const AssociateVPCWithHostedZoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::AssociateVPCWithHostedZone, request, handler, context);
        }
 
        virtual Model::ChangeCidrCollectionOutcome ChangeCidrCollection(const Model::ChangeCidrCollectionRequest& request) const;
 
        template<typename ChangeCidrCollectionRequestT = Model::ChangeCidrCollectionRequest>
        Model::ChangeCidrCollectionOutcomeCallable ChangeCidrCollectionCallable(const ChangeCidrCollectionRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ChangeCidrCollection, request);
        }
 
        template<typename ChangeCidrCollectionRequestT = Model::ChangeCidrCollectionRequest>
        void ChangeCidrCollectionAsync(const ChangeCidrCollectionRequestT& request, const ChangeCidrCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ChangeCidrCollection, request, handler, context);
        }
 
        virtual Model::ChangeResourceRecordSetsOutcome ChangeResourceRecordSets(const Model::ChangeResourceRecordSetsRequest& request) const;
 
        template<typename ChangeResourceRecordSetsRequestT = Model::ChangeResourceRecordSetsRequest>
        Model::ChangeResourceRecordSetsOutcomeCallable ChangeResourceRecordSetsCallable(const ChangeResourceRecordSetsRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ChangeResourceRecordSets, request);
        }
 
        template<typename ChangeResourceRecordSetsRequestT = Model::ChangeResourceRecordSetsRequest>
        void ChangeResourceRecordSetsAsync(const ChangeResourceRecordSetsRequestT& request, const ChangeResourceRecordSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ChangeResourceRecordSets, request, handler, context);
        }
 
        virtual Model::ChangeTagsForResourceOutcome ChangeTagsForResource(const Model::ChangeTagsForResourceRequest& request) const;
 
        template<typename ChangeTagsForResourceRequestT = Model::ChangeTagsForResourceRequest>
        Model::ChangeTagsForResourceOutcomeCallable ChangeTagsForResourceCallable(const ChangeTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ChangeTagsForResource, request);
        }
 
        template<typename ChangeTagsForResourceRequestT = Model::ChangeTagsForResourceRequest>
        void ChangeTagsForResourceAsync(const ChangeTagsForResourceRequestT& request, const ChangeTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ChangeTagsForResource, request, handler, context);
        }
 
        virtual Model::CreateCidrCollectionOutcome CreateCidrCollection(const Model::CreateCidrCollectionRequest& request) const;
 
        template<typename CreateCidrCollectionRequestT = Model::CreateCidrCollectionRequest>
        Model::CreateCidrCollectionOutcomeCallable CreateCidrCollectionCallable(const CreateCidrCollectionRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateCidrCollection, request);
        }
 
        template<typename CreateCidrCollectionRequestT = Model::CreateCidrCollectionRequest>
        void CreateCidrCollectionAsync(const CreateCidrCollectionRequestT& request, const CreateCidrCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateCidrCollection, request, handler, context);
        }
 
        virtual Model::CreateHealthCheckOutcome CreateHealthCheck(const Model::CreateHealthCheckRequest& request) const;
 
        template<typename CreateHealthCheckRequestT = Model::CreateHealthCheckRequest>
        Model::CreateHealthCheckOutcomeCallable CreateHealthCheckCallable(const CreateHealthCheckRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateHealthCheck, request);
        }
 
        template<typename CreateHealthCheckRequestT = Model::CreateHealthCheckRequest>
        void CreateHealthCheckAsync(const CreateHealthCheckRequestT& request, const CreateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateHealthCheck, request, handler, context);
        }
 
        virtual Model::CreateHostedZoneOutcome CreateHostedZone(const Model::CreateHostedZoneRequest& request) const;
 
        template<typename CreateHostedZoneRequestT = Model::CreateHostedZoneRequest>
        Model::CreateHostedZoneOutcomeCallable CreateHostedZoneCallable(const CreateHostedZoneRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateHostedZone, request);
        }
 
        template<typename CreateHostedZoneRequestT = Model::CreateHostedZoneRequest>
        void CreateHostedZoneAsync(const CreateHostedZoneRequestT& request, const CreateHostedZoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateHostedZone, request, handler, context);
        }
 
        virtual Model::CreateKeySigningKeyOutcome CreateKeySigningKey(const Model::CreateKeySigningKeyRequest& request) const;
 
        template<typename CreateKeySigningKeyRequestT = Model::CreateKeySigningKeyRequest>
        Model::CreateKeySigningKeyOutcomeCallable CreateKeySigningKeyCallable(const CreateKeySigningKeyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateKeySigningKey, request);
        }
 
        template<typename CreateKeySigningKeyRequestT = Model::CreateKeySigningKeyRequest>
        void CreateKeySigningKeyAsync(const CreateKeySigningKeyRequestT& request, const CreateKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateKeySigningKey, request, handler, context);
        }
 
        virtual Model::CreateQueryLoggingConfigOutcome CreateQueryLoggingConfig(const Model::CreateQueryLoggingConfigRequest& request) const;
 
        template<typename CreateQueryLoggingConfigRequestT = Model::CreateQueryLoggingConfigRequest>
        Model::CreateQueryLoggingConfigOutcomeCallable CreateQueryLoggingConfigCallable(const CreateQueryLoggingConfigRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateQueryLoggingConfig, request);
        }
 
        template<typename CreateQueryLoggingConfigRequestT = Model::CreateQueryLoggingConfigRequest>
        void CreateQueryLoggingConfigAsync(const CreateQueryLoggingConfigRequestT& request, const CreateQueryLoggingConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateQueryLoggingConfig, request, handler, context);
        }
 
        virtual Model::CreateReusableDelegationSetOutcome CreateReusableDelegationSet(const Model::CreateReusableDelegationSetRequest& request) const;
 
        template<typename CreateReusableDelegationSetRequestT = Model::CreateReusableDelegationSetRequest>
        Model::CreateReusableDelegationSetOutcomeCallable CreateReusableDelegationSetCallable(const CreateReusableDelegationSetRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateReusableDelegationSet, request);
        }
 
        template<typename CreateReusableDelegationSetRequestT = Model::CreateReusableDelegationSetRequest>
        void CreateReusableDelegationSetAsync(const CreateReusableDelegationSetRequestT& request, const CreateReusableDelegationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateReusableDelegationSet, request, handler, context);
        }
 
        virtual Model::CreateTrafficPolicyOutcome CreateTrafficPolicy(const Model::CreateTrafficPolicyRequest& request) const;
 
        template<typename CreateTrafficPolicyRequestT = Model::CreateTrafficPolicyRequest>
        Model::CreateTrafficPolicyOutcomeCallable CreateTrafficPolicyCallable(const CreateTrafficPolicyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateTrafficPolicy, request);
        }
 
        template<typename CreateTrafficPolicyRequestT = Model::CreateTrafficPolicyRequest>
        void CreateTrafficPolicyAsync(const CreateTrafficPolicyRequestT& request, const CreateTrafficPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateTrafficPolicy, request, handler, context);
        }
 
        virtual Model::CreateTrafficPolicyInstanceOutcome CreateTrafficPolicyInstance(const Model::CreateTrafficPolicyInstanceRequest& request) const;
 
        template<typename CreateTrafficPolicyInstanceRequestT = Model::CreateTrafficPolicyInstanceRequest>
        Model::CreateTrafficPolicyInstanceOutcomeCallable CreateTrafficPolicyInstanceCallable(const CreateTrafficPolicyInstanceRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateTrafficPolicyInstance, request);
        }
 
        template<typename CreateTrafficPolicyInstanceRequestT = Model::CreateTrafficPolicyInstanceRequest>
        void CreateTrafficPolicyInstanceAsync(const CreateTrafficPolicyInstanceRequestT& request, const CreateTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateTrafficPolicyInstance, request, handler, context);
        }
 
        virtual Model::CreateTrafficPolicyVersionOutcome CreateTrafficPolicyVersion(const Model::CreateTrafficPolicyVersionRequest& request) const;
 
        template<typename CreateTrafficPolicyVersionRequestT = Model::CreateTrafficPolicyVersionRequest>
        Model::CreateTrafficPolicyVersionOutcomeCallable CreateTrafficPolicyVersionCallable(const CreateTrafficPolicyVersionRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateTrafficPolicyVersion, request);
        }
 
        template<typename CreateTrafficPolicyVersionRequestT = Model::CreateTrafficPolicyVersionRequest>
        void CreateTrafficPolicyVersionAsync(const CreateTrafficPolicyVersionRequestT& request, const CreateTrafficPolicyVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateTrafficPolicyVersion, request, handler, context);
        }
 
        virtual Model::CreateVPCAssociationAuthorizationOutcome CreateVPCAssociationAuthorization(const Model::CreateVPCAssociationAuthorizationRequest& request) const;
 
        template<typename CreateVPCAssociationAuthorizationRequestT = Model::CreateVPCAssociationAuthorizationRequest>
        Model::CreateVPCAssociationAuthorizationOutcomeCallable CreateVPCAssociationAuthorizationCallable(const CreateVPCAssociationAuthorizationRequestT& request) const
        {
            return SubmitCallable(&Route53Client::CreateVPCAssociationAuthorization, request);
        }
 
        template<typename CreateVPCAssociationAuthorizationRequestT = Model::CreateVPCAssociationAuthorizationRequest>
        void CreateVPCAssociationAuthorizationAsync(const CreateVPCAssociationAuthorizationRequestT& request, const CreateVPCAssociationAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::CreateVPCAssociationAuthorization, request, handler, context);
        }
 
        virtual Model::DeactivateKeySigningKeyOutcome DeactivateKeySigningKey(const Model::DeactivateKeySigningKeyRequest& request) const;
 
        template<typename DeactivateKeySigningKeyRequestT = Model::DeactivateKeySigningKeyRequest>
        Model::DeactivateKeySigningKeyOutcomeCallable DeactivateKeySigningKeyCallable(const DeactivateKeySigningKeyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeactivateKeySigningKey, request);
        }
 
        template<typename DeactivateKeySigningKeyRequestT = Model::DeactivateKeySigningKeyRequest>
        void DeactivateKeySigningKeyAsync(const DeactivateKeySigningKeyRequestT& request, const DeactivateKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeactivateKeySigningKey, request, handler, context);
        }
 
        virtual Model::DeleteCidrCollectionOutcome DeleteCidrCollection(const Model::DeleteCidrCollectionRequest& request) const;
 
        template<typename DeleteCidrCollectionRequestT = Model::DeleteCidrCollectionRequest>
        Model::DeleteCidrCollectionOutcomeCallable DeleteCidrCollectionCallable(const DeleteCidrCollectionRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteCidrCollection, request);
        }
 
        template<typename DeleteCidrCollectionRequestT = Model::DeleteCidrCollectionRequest>
        void DeleteCidrCollectionAsync(const DeleteCidrCollectionRequestT& request, const DeleteCidrCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteCidrCollection, request, handler, context);
        }
 
        virtual Model::DeleteHealthCheckOutcome DeleteHealthCheck(const Model::DeleteHealthCheckRequest& request) const;
 
        template<typename DeleteHealthCheckRequestT = Model::DeleteHealthCheckRequest>
        Model::DeleteHealthCheckOutcomeCallable DeleteHealthCheckCallable(const DeleteHealthCheckRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteHealthCheck, request);
        }
 
        template<typename DeleteHealthCheckRequestT = Model::DeleteHealthCheckRequest>
        void DeleteHealthCheckAsync(const DeleteHealthCheckRequestT& request, const DeleteHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteHealthCheck, request, handler, context);
        }
 
        virtual Model::DeleteHostedZoneOutcome DeleteHostedZone(const Model::DeleteHostedZoneRequest& request) const;
 
        template<typename DeleteHostedZoneRequestT = Model::DeleteHostedZoneRequest>
        Model::DeleteHostedZoneOutcomeCallable DeleteHostedZoneCallable(const DeleteHostedZoneRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteHostedZone, request);
        }
 
        template<typename DeleteHostedZoneRequestT = Model::DeleteHostedZoneRequest>
        void DeleteHostedZoneAsync(const DeleteHostedZoneRequestT& request, const DeleteHostedZoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteHostedZone, request, handler, context);
        }
 
        virtual Model::DeleteKeySigningKeyOutcome DeleteKeySigningKey(const Model::DeleteKeySigningKeyRequest& request) const;
 
        template<typename DeleteKeySigningKeyRequestT = Model::DeleteKeySigningKeyRequest>
        Model::DeleteKeySigningKeyOutcomeCallable DeleteKeySigningKeyCallable(const DeleteKeySigningKeyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteKeySigningKey, request);
        }
 
        template<typename DeleteKeySigningKeyRequestT = Model::DeleteKeySigningKeyRequest>
        void DeleteKeySigningKeyAsync(const DeleteKeySigningKeyRequestT& request, const DeleteKeySigningKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteKeySigningKey, request, handler, context);
        }
 
        virtual Model::DeleteQueryLoggingConfigOutcome DeleteQueryLoggingConfig(const Model::DeleteQueryLoggingConfigRequest& request) const;
 
        template<typename DeleteQueryLoggingConfigRequestT = Model::DeleteQueryLoggingConfigRequest>
        Model::DeleteQueryLoggingConfigOutcomeCallable DeleteQueryLoggingConfigCallable(const DeleteQueryLoggingConfigRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteQueryLoggingConfig, request);
        }
 
        template<typename DeleteQueryLoggingConfigRequestT = Model::DeleteQueryLoggingConfigRequest>
        void DeleteQueryLoggingConfigAsync(const DeleteQueryLoggingConfigRequestT& request, const DeleteQueryLoggingConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteQueryLoggingConfig, request, handler, context);
        }
 
        virtual Model::DeleteReusableDelegationSetOutcome DeleteReusableDelegationSet(const Model::DeleteReusableDelegationSetRequest& request) const;
 
        template<typename DeleteReusableDelegationSetRequestT = Model::DeleteReusableDelegationSetRequest>
        Model::DeleteReusableDelegationSetOutcomeCallable DeleteReusableDelegationSetCallable(const DeleteReusableDelegationSetRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteReusableDelegationSet, request);
        }
 
        template<typename DeleteReusableDelegationSetRequestT = Model::DeleteReusableDelegationSetRequest>
        void DeleteReusableDelegationSetAsync(const DeleteReusableDelegationSetRequestT& request, const DeleteReusableDelegationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteReusableDelegationSet, request, handler, context);
        }
 
        virtual Model::DeleteTrafficPolicyOutcome DeleteTrafficPolicy(const Model::DeleteTrafficPolicyRequest& request) const;
 
        template<typename DeleteTrafficPolicyRequestT = Model::DeleteTrafficPolicyRequest>
        Model::DeleteTrafficPolicyOutcomeCallable DeleteTrafficPolicyCallable(const DeleteTrafficPolicyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteTrafficPolicy, request);
        }
 
        template<typename DeleteTrafficPolicyRequestT = Model::DeleteTrafficPolicyRequest>
        void DeleteTrafficPolicyAsync(const DeleteTrafficPolicyRequestT& request, const DeleteTrafficPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteTrafficPolicy, request, handler, context);
        }
 
        virtual Model::DeleteTrafficPolicyInstanceOutcome DeleteTrafficPolicyInstance(const Model::DeleteTrafficPolicyInstanceRequest& request) const;
 
        template<typename DeleteTrafficPolicyInstanceRequestT = Model::DeleteTrafficPolicyInstanceRequest>
        Model::DeleteTrafficPolicyInstanceOutcomeCallable DeleteTrafficPolicyInstanceCallable(const DeleteTrafficPolicyInstanceRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteTrafficPolicyInstance, request);
        }
 
        template<typename DeleteTrafficPolicyInstanceRequestT = Model::DeleteTrafficPolicyInstanceRequest>
        void DeleteTrafficPolicyInstanceAsync(const DeleteTrafficPolicyInstanceRequestT& request, const DeleteTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteTrafficPolicyInstance, request, handler, context);
        }
 
        virtual Model::DeleteVPCAssociationAuthorizationOutcome DeleteVPCAssociationAuthorization(const Model::DeleteVPCAssociationAuthorizationRequest& request) const;
 
        template<typename DeleteVPCAssociationAuthorizationRequestT = Model::DeleteVPCAssociationAuthorizationRequest>
        Model::DeleteVPCAssociationAuthorizationOutcomeCallable DeleteVPCAssociationAuthorizationCallable(const DeleteVPCAssociationAuthorizationRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DeleteVPCAssociationAuthorization, request);
        }
 
        template<typename DeleteVPCAssociationAuthorizationRequestT = Model::DeleteVPCAssociationAuthorizationRequest>
        void DeleteVPCAssociationAuthorizationAsync(const DeleteVPCAssociationAuthorizationRequestT& request, const DeleteVPCAssociationAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DeleteVPCAssociationAuthorization, request, handler, context);
        }
 
        virtual Model::DisableHostedZoneDNSSECOutcome DisableHostedZoneDNSSEC(const Model::DisableHostedZoneDNSSECRequest& request) const;
 
        template<typename DisableHostedZoneDNSSECRequestT = Model::DisableHostedZoneDNSSECRequest>
        Model::DisableHostedZoneDNSSECOutcomeCallable DisableHostedZoneDNSSECCallable(const DisableHostedZoneDNSSECRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DisableHostedZoneDNSSEC, request);
        }
 
        template<typename DisableHostedZoneDNSSECRequestT = Model::DisableHostedZoneDNSSECRequest>
        void DisableHostedZoneDNSSECAsync(const DisableHostedZoneDNSSECRequestT& request, const DisableHostedZoneDNSSECResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DisableHostedZoneDNSSEC, request, handler, context);
        }
 
        virtual Model::DisassociateVPCFromHostedZoneOutcome DisassociateVPCFromHostedZone(const Model::DisassociateVPCFromHostedZoneRequest& request) const;
 
        template<typename DisassociateVPCFromHostedZoneRequestT = Model::DisassociateVPCFromHostedZoneRequest>
        Model::DisassociateVPCFromHostedZoneOutcomeCallable DisassociateVPCFromHostedZoneCallable(const DisassociateVPCFromHostedZoneRequestT& request) const
        {
            return SubmitCallable(&Route53Client::DisassociateVPCFromHostedZone, request);
        }
 
        template<typename DisassociateVPCFromHostedZoneRequestT = Model::DisassociateVPCFromHostedZoneRequest>
        void DisassociateVPCFromHostedZoneAsync(const DisassociateVPCFromHostedZoneRequestT& request, const DisassociateVPCFromHostedZoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::DisassociateVPCFromHostedZone, request, handler, context);
        }
 
        virtual Model::EnableHostedZoneDNSSECOutcome EnableHostedZoneDNSSEC(const Model::EnableHostedZoneDNSSECRequest& request) const;
 
        template<typename EnableHostedZoneDNSSECRequestT = Model::EnableHostedZoneDNSSECRequest>
        Model::EnableHostedZoneDNSSECOutcomeCallable EnableHostedZoneDNSSECCallable(const EnableHostedZoneDNSSECRequestT& request) const
        {
            return SubmitCallable(&Route53Client::EnableHostedZoneDNSSEC, request);
        }
 
        template<typename EnableHostedZoneDNSSECRequestT = Model::EnableHostedZoneDNSSECRequest>
        void EnableHostedZoneDNSSECAsync(const EnableHostedZoneDNSSECRequestT& request, const EnableHostedZoneDNSSECResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::EnableHostedZoneDNSSEC, request, handler, context);
        }
 
        virtual Model::GetAccountLimitOutcome GetAccountLimit(const Model::GetAccountLimitRequest& request) const;
 
        template<typename GetAccountLimitRequestT = Model::GetAccountLimitRequest>
        Model::GetAccountLimitOutcomeCallable GetAccountLimitCallable(const GetAccountLimitRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetAccountLimit, request);
        }
 
        template<typename GetAccountLimitRequestT = Model::GetAccountLimitRequest>
        void GetAccountLimitAsync(const GetAccountLimitRequestT& request, const GetAccountLimitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetAccountLimit, request, handler, context);
        }
 
        virtual Model::GetChangeOutcome GetChange(const Model::GetChangeRequest& request) const;
 
        template<typename GetChangeRequestT = Model::GetChangeRequest>
        Model::GetChangeOutcomeCallable GetChangeCallable(const GetChangeRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetChange, request);
        }
 
        template<typename GetChangeRequestT = Model::GetChangeRequest>
        void GetChangeAsync(const GetChangeRequestT& request, const GetChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetChange, request, handler, context);
        }
 
        virtual Model::GetCheckerIpRangesOutcome GetCheckerIpRanges(const Model::GetCheckerIpRangesRequest& request = {}) const;
 
        template<typename GetCheckerIpRangesRequestT = Model::GetCheckerIpRangesRequest>
        Model::GetCheckerIpRangesOutcomeCallable GetCheckerIpRangesCallable(const GetCheckerIpRangesRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::GetCheckerIpRanges, request);
        }
 
        template<typename GetCheckerIpRangesRequestT = Model::GetCheckerIpRangesRequest>
        void GetCheckerIpRangesAsync(const GetCheckerIpRangesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCheckerIpRangesRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::GetCheckerIpRanges, request, handler, context);
        }
 
        virtual Model::GetDNSSECOutcome GetDNSSEC(const Model::GetDNSSECRequest& request) const;
 
        template<typename GetDNSSECRequestT = Model::GetDNSSECRequest>
        Model::GetDNSSECOutcomeCallable GetDNSSECCallable(const GetDNSSECRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetDNSSEC, request);
        }
 
        template<typename GetDNSSECRequestT = Model::GetDNSSECRequest>
        void GetDNSSECAsync(const GetDNSSECRequestT& request, const GetDNSSECResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetDNSSEC, request, handler, context);
        }
 
        virtual Model::GetGeoLocationOutcome GetGeoLocation(const Model::GetGeoLocationRequest& request = {}) const;
 
        template<typename GetGeoLocationRequestT = Model::GetGeoLocationRequest>
        Model::GetGeoLocationOutcomeCallable GetGeoLocationCallable(const GetGeoLocationRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::GetGeoLocation, request);
        }
 
        template<typename GetGeoLocationRequestT = Model::GetGeoLocationRequest>
        void GetGeoLocationAsync(const GetGeoLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGeoLocationRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::GetGeoLocation, request, handler, context);
        }
 
        virtual Model::GetHealthCheckOutcome GetHealthCheck(const Model::GetHealthCheckRequest& request) const;
 
        template<typename GetHealthCheckRequestT = Model::GetHealthCheckRequest>
        Model::GetHealthCheckOutcomeCallable GetHealthCheckCallable(const GetHealthCheckRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetHealthCheck, request);
        }
 
        template<typename GetHealthCheckRequestT = Model::GetHealthCheckRequest>
        void GetHealthCheckAsync(const GetHealthCheckRequestT& request, const GetHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetHealthCheck, request, handler, context);
        }
 
        virtual Model::GetHealthCheckCountOutcome GetHealthCheckCount(const Model::GetHealthCheckCountRequest& request = {}) const;
 
        template<typename GetHealthCheckCountRequestT = Model::GetHealthCheckCountRequest>
        Model::GetHealthCheckCountOutcomeCallable GetHealthCheckCountCallable(const GetHealthCheckCountRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::GetHealthCheckCount, request);
        }
 
        template<typename GetHealthCheckCountRequestT = Model::GetHealthCheckCountRequest>
        void GetHealthCheckCountAsync(const GetHealthCheckCountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetHealthCheckCountRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::GetHealthCheckCount, request, handler, context);
        }
 
        virtual Model::GetHealthCheckLastFailureReasonOutcome GetHealthCheckLastFailureReason(const Model::GetHealthCheckLastFailureReasonRequest& request) const;
 
        template<typename GetHealthCheckLastFailureReasonRequestT = Model::GetHealthCheckLastFailureReasonRequest>
        Model::GetHealthCheckLastFailureReasonOutcomeCallable GetHealthCheckLastFailureReasonCallable(const GetHealthCheckLastFailureReasonRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetHealthCheckLastFailureReason, request);
        }
 
        template<typename GetHealthCheckLastFailureReasonRequestT = Model::GetHealthCheckLastFailureReasonRequest>
        void GetHealthCheckLastFailureReasonAsync(const GetHealthCheckLastFailureReasonRequestT& request, const GetHealthCheckLastFailureReasonResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetHealthCheckLastFailureReason, request, handler, context);
        }
 
        virtual Model::GetHealthCheckStatusOutcome GetHealthCheckStatus(const Model::GetHealthCheckStatusRequest& request) const;
 
        template<typename GetHealthCheckStatusRequestT = Model::GetHealthCheckStatusRequest>
        Model::GetHealthCheckStatusOutcomeCallable GetHealthCheckStatusCallable(const GetHealthCheckStatusRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetHealthCheckStatus, request);
        }
 
        template<typename GetHealthCheckStatusRequestT = Model::GetHealthCheckStatusRequest>
        void GetHealthCheckStatusAsync(const GetHealthCheckStatusRequestT& request, const GetHealthCheckStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetHealthCheckStatus, request, handler, context);
        }
 
        virtual Model::GetHostedZoneOutcome GetHostedZone(const Model::GetHostedZoneRequest& request) const;
 
        template<typename GetHostedZoneRequestT = Model::GetHostedZoneRequest>
        Model::GetHostedZoneOutcomeCallable GetHostedZoneCallable(const GetHostedZoneRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetHostedZone, request);
        }
 
        template<typename GetHostedZoneRequestT = Model::GetHostedZoneRequest>
        void GetHostedZoneAsync(const GetHostedZoneRequestT& request, const GetHostedZoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetHostedZone, request, handler, context);
        }
 
        virtual Model::GetHostedZoneCountOutcome GetHostedZoneCount(const Model::GetHostedZoneCountRequest& request = {}) const;
 
        template<typename GetHostedZoneCountRequestT = Model::GetHostedZoneCountRequest>
        Model::GetHostedZoneCountOutcomeCallable GetHostedZoneCountCallable(const GetHostedZoneCountRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::GetHostedZoneCount, request);
        }
 
        template<typename GetHostedZoneCountRequestT = Model::GetHostedZoneCountRequest>
        void GetHostedZoneCountAsync(const GetHostedZoneCountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetHostedZoneCountRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::GetHostedZoneCount, request, handler, context);
        }
 
        virtual Model::GetHostedZoneLimitOutcome GetHostedZoneLimit(const Model::GetHostedZoneLimitRequest& request) const;
 
        template<typename GetHostedZoneLimitRequestT = Model::GetHostedZoneLimitRequest>
        Model::GetHostedZoneLimitOutcomeCallable GetHostedZoneLimitCallable(const GetHostedZoneLimitRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetHostedZoneLimit, request);
        }
 
        template<typename GetHostedZoneLimitRequestT = Model::GetHostedZoneLimitRequest>
        void GetHostedZoneLimitAsync(const GetHostedZoneLimitRequestT& request, const GetHostedZoneLimitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetHostedZoneLimit, request, handler, context);
        }
 
        virtual Model::GetQueryLoggingConfigOutcome GetQueryLoggingConfig(const Model::GetQueryLoggingConfigRequest& request) const;
 
        template<typename GetQueryLoggingConfigRequestT = Model::GetQueryLoggingConfigRequest>
        Model::GetQueryLoggingConfigOutcomeCallable GetQueryLoggingConfigCallable(const GetQueryLoggingConfigRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetQueryLoggingConfig, request);
        }
 
        template<typename GetQueryLoggingConfigRequestT = Model::GetQueryLoggingConfigRequest>
        void GetQueryLoggingConfigAsync(const GetQueryLoggingConfigRequestT& request, const GetQueryLoggingConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetQueryLoggingConfig, request, handler, context);
        }
 
        virtual Model::GetReusableDelegationSetOutcome GetReusableDelegationSet(const Model::GetReusableDelegationSetRequest& request) const;
 
        template<typename GetReusableDelegationSetRequestT = Model::GetReusableDelegationSetRequest>
        Model::GetReusableDelegationSetOutcomeCallable GetReusableDelegationSetCallable(const GetReusableDelegationSetRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetReusableDelegationSet, request);
        }
 
        template<typename GetReusableDelegationSetRequestT = Model::GetReusableDelegationSetRequest>
        void GetReusableDelegationSetAsync(const GetReusableDelegationSetRequestT& request, const GetReusableDelegationSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetReusableDelegationSet, request, handler, context);
        }
 
        virtual Model::GetReusableDelegationSetLimitOutcome GetReusableDelegationSetLimit(const Model::GetReusableDelegationSetLimitRequest& request) const;
 
        template<typename GetReusableDelegationSetLimitRequestT = Model::GetReusableDelegationSetLimitRequest>
        Model::GetReusableDelegationSetLimitOutcomeCallable GetReusableDelegationSetLimitCallable(const GetReusableDelegationSetLimitRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetReusableDelegationSetLimit, request);
        }
 
        template<typename GetReusableDelegationSetLimitRequestT = Model::GetReusableDelegationSetLimitRequest>
        void GetReusableDelegationSetLimitAsync(const GetReusableDelegationSetLimitRequestT& request, const GetReusableDelegationSetLimitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetReusableDelegationSetLimit, request, handler, context);
        }
 
        virtual Model::GetTrafficPolicyOutcome GetTrafficPolicy(const Model::GetTrafficPolicyRequest& request) const;
 
        template<typename GetTrafficPolicyRequestT = Model::GetTrafficPolicyRequest>
        Model::GetTrafficPolicyOutcomeCallable GetTrafficPolicyCallable(const GetTrafficPolicyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetTrafficPolicy, request);
        }
 
        template<typename GetTrafficPolicyRequestT = Model::GetTrafficPolicyRequest>
        void GetTrafficPolicyAsync(const GetTrafficPolicyRequestT& request, const GetTrafficPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetTrafficPolicy, request, handler, context);
        }
 
        virtual Model::GetTrafficPolicyInstanceOutcome GetTrafficPolicyInstance(const Model::GetTrafficPolicyInstanceRequest& request) const;
 
        template<typename GetTrafficPolicyInstanceRequestT = Model::GetTrafficPolicyInstanceRequest>
        Model::GetTrafficPolicyInstanceOutcomeCallable GetTrafficPolicyInstanceCallable(const GetTrafficPolicyInstanceRequestT& request) const
        {
            return SubmitCallable(&Route53Client::GetTrafficPolicyInstance, request);
        }
 
        template<typename GetTrafficPolicyInstanceRequestT = Model::GetTrafficPolicyInstanceRequest>
        void GetTrafficPolicyInstanceAsync(const GetTrafficPolicyInstanceRequestT& request, const GetTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::GetTrafficPolicyInstance, request, handler, context);
        }
 
        virtual Model::GetTrafficPolicyInstanceCountOutcome GetTrafficPolicyInstanceCount(const Model::GetTrafficPolicyInstanceCountRequest& request = {}) const;
 
        template<typename GetTrafficPolicyInstanceCountRequestT = Model::GetTrafficPolicyInstanceCountRequest>
        Model::GetTrafficPolicyInstanceCountOutcomeCallable GetTrafficPolicyInstanceCountCallable(const GetTrafficPolicyInstanceCountRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::GetTrafficPolicyInstanceCount, request);
        }
 
        template<typename GetTrafficPolicyInstanceCountRequestT = Model::GetTrafficPolicyInstanceCountRequest>
        void GetTrafficPolicyInstanceCountAsync(const GetTrafficPolicyInstanceCountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetTrafficPolicyInstanceCountRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::GetTrafficPolicyInstanceCount, request, handler, context);
        }
 
        virtual Model::ListCidrBlocksOutcome ListCidrBlocks(const Model::ListCidrBlocksRequest& request) const;
 
        template<typename ListCidrBlocksRequestT = Model::ListCidrBlocksRequest>
        Model::ListCidrBlocksOutcomeCallable ListCidrBlocksCallable(const ListCidrBlocksRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListCidrBlocks, request);
        }
 
        template<typename ListCidrBlocksRequestT = Model::ListCidrBlocksRequest>
        void ListCidrBlocksAsync(const ListCidrBlocksRequestT& request, const ListCidrBlocksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListCidrBlocks, request, handler, context);
        }
 
        virtual Model::ListCidrCollectionsOutcome ListCidrCollections(const Model::ListCidrCollectionsRequest& request = {}) const;
 
        template<typename ListCidrCollectionsRequestT = Model::ListCidrCollectionsRequest>
        Model::ListCidrCollectionsOutcomeCallable ListCidrCollectionsCallable(const ListCidrCollectionsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListCidrCollections, request);
        }
 
        template<typename ListCidrCollectionsRequestT = Model::ListCidrCollectionsRequest>
        void ListCidrCollectionsAsync(const ListCidrCollectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCidrCollectionsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListCidrCollections, request, handler, context);
        }
 
        virtual Model::ListCidrLocationsOutcome ListCidrLocations(const Model::ListCidrLocationsRequest& request) const;
 
        template<typename ListCidrLocationsRequestT = Model::ListCidrLocationsRequest>
        Model::ListCidrLocationsOutcomeCallable ListCidrLocationsCallable(const ListCidrLocationsRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListCidrLocations, request);
        }
 
        template<typename ListCidrLocationsRequestT = Model::ListCidrLocationsRequest>
        void ListCidrLocationsAsync(const ListCidrLocationsRequestT& request, const ListCidrLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListCidrLocations, request, handler, context);
        }
 
        virtual Model::ListGeoLocationsOutcome ListGeoLocations(const Model::ListGeoLocationsRequest& request = {}) const;
 
        template<typename ListGeoLocationsRequestT = Model::ListGeoLocationsRequest>
        Model::ListGeoLocationsOutcomeCallable ListGeoLocationsCallable(const ListGeoLocationsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListGeoLocations, request);
        }
 
        template<typename ListGeoLocationsRequestT = Model::ListGeoLocationsRequest>
        void ListGeoLocationsAsync(const ListGeoLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListGeoLocationsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListGeoLocations, request, handler, context);
        }
 
        virtual Model::ListHealthChecksOutcome ListHealthChecks(const Model::ListHealthChecksRequest& request = {}) const;
 
        template<typename ListHealthChecksRequestT = Model::ListHealthChecksRequest>
        Model::ListHealthChecksOutcomeCallable ListHealthChecksCallable(const ListHealthChecksRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListHealthChecks, request);
        }
 
        template<typename ListHealthChecksRequestT = Model::ListHealthChecksRequest>
        void ListHealthChecksAsync(const ListHealthChecksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListHealthChecksRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListHealthChecks, request, handler, context);
        }
 
        virtual Model::ListHostedZonesOutcome ListHostedZones(const Model::ListHostedZonesRequest& request = {}) const;
 
        template<typename ListHostedZonesRequestT = Model::ListHostedZonesRequest>
        Model::ListHostedZonesOutcomeCallable ListHostedZonesCallable(const ListHostedZonesRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListHostedZones, request);
        }
 
        template<typename ListHostedZonesRequestT = Model::ListHostedZonesRequest>
        void ListHostedZonesAsync(const ListHostedZonesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListHostedZonesRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListHostedZones, request, handler, context);
        }
 
        virtual Model::ListHostedZonesByNameOutcome ListHostedZonesByName(const Model::ListHostedZonesByNameRequest& request = {}) const;
 
        template<typename ListHostedZonesByNameRequestT = Model::ListHostedZonesByNameRequest>
        Model::ListHostedZonesByNameOutcomeCallable ListHostedZonesByNameCallable(const ListHostedZonesByNameRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListHostedZonesByName, request);
        }
 
        template<typename ListHostedZonesByNameRequestT = Model::ListHostedZonesByNameRequest>
        void ListHostedZonesByNameAsync(const ListHostedZonesByNameResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListHostedZonesByNameRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListHostedZonesByName, request, handler, context);
        }
 
        virtual Model::ListHostedZonesByVPCOutcome ListHostedZonesByVPC(const Model::ListHostedZonesByVPCRequest& request) const;
 
        template<typename ListHostedZonesByVPCRequestT = Model::ListHostedZonesByVPCRequest>
        Model::ListHostedZonesByVPCOutcomeCallable ListHostedZonesByVPCCallable(const ListHostedZonesByVPCRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListHostedZonesByVPC, request);
        }
 
        template<typename ListHostedZonesByVPCRequestT = Model::ListHostedZonesByVPCRequest>
        void ListHostedZonesByVPCAsync(const ListHostedZonesByVPCRequestT& request, const ListHostedZonesByVPCResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListHostedZonesByVPC, request, handler, context);
        }
 
        virtual Model::ListQueryLoggingConfigsOutcome ListQueryLoggingConfigs(const Model::ListQueryLoggingConfigsRequest& request = {}) const;
 
        template<typename ListQueryLoggingConfigsRequestT = Model::ListQueryLoggingConfigsRequest>
        Model::ListQueryLoggingConfigsOutcomeCallable ListQueryLoggingConfigsCallable(const ListQueryLoggingConfigsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListQueryLoggingConfigs, request);
        }
 
        template<typename ListQueryLoggingConfigsRequestT = Model::ListQueryLoggingConfigsRequest>
        void ListQueryLoggingConfigsAsync(const ListQueryLoggingConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListQueryLoggingConfigsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListQueryLoggingConfigs, request, handler, context);
        }
 
        virtual Model::ListResourceRecordSetsOutcome ListResourceRecordSets(const Model::ListResourceRecordSetsRequest& request) const;
 
        template<typename ListResourceRecordSetsRequestT = Model::ListResourceRecordSetsRequest>
        Model::ListResourceRecordSetsOutcomeCallable ListResourceRecordSetsCallable(const ListResourceRecordSetsRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListResourceRecordSets, request);
        }
 
        template<typename ListResourceRecordSetsRequestT = Model::ListResourceRecordSetsRequest>
        void ListResourceRecordSetsAsync(const ListResourceRecordSetsRequestT& request, const ListResourceRecordSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListResourceRecordSets, request, handler, context);
        }
 
        virtual Model::ListReusableDelegationSetsOutcome ListReusableDelegationSets(const Model::ListReusableDelegationSetsRequest& request = {}) const;
 
        template<typename ListReusableDelegationSetsRequestT = Model::ListReusableDelegationSetsRequest>
        Model::ListReusableDelegationSetsOutcomeCallable ListReusableDelegationSetsCallable(const ListReusableDelegationSetsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListReusableDelegationSets, request);
        }
 
        template<typename ListReusableDelegationSetsRequestT = Model::ListReusableDelegationSetsRequest>
        void ListReusableDelegationSetsAsync(const ListReusableDelegationSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReusableDelegationSetsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListReusableDelegationSets, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTagsForResourcesOutcome ListTagsForResources(const Model::ListTagsForResourcesRequest& request) const;
 
        template<typename ListTagsForResourcesRequestT = Model::ListTagsForResourcesRequest>
        Model::ListTagsForResourcesOutcomeCallable ListTagsForResourcesCallable(const ListTagsForResourcesRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListTagsForResources, request);
        }
 
        template<typename ListTagsForResourcesRequestT = Model::ListTagsForResourcesRequest>
        void ListTagsForResourcesAsync(const ListTagsForResourcesRequestT& request, const ListTagsForResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListTagsForResources, request, handler, context);
        }
 
        virtual Model::ListTrafficPoliciesOutcome ListTrafficPolicies(const Model::ListTrafficPoliciesRequest& request = {}) const;
 
        template<typename ListTrafficPoliciesRequestT = Model::ListTrafficPoliciesRequest>
        Model::ListTrafficPoliciesOutcomeCallable ListTrafficPoliciesCallable(const ListTrafficPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListTrafficPolicies, request);
        }
 
        template<typename ListTrafficPoliciesRequestT = Model::ListTrafficPoliciesRequest>
        void ListTrafficPoliciesAsync(const ListTrafficPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTrafficPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListTrafficPolicies, request, handler, context);
        }
 
        virtual Model::ListTrafficPolicyInstancesOutcome ListTrafficPolicyInstances(const Model::ListTrafficPolicyInstancesRequest& request = {}) const;
 
        template<typename ListTrafficPolicyInstancesRequestT = Model::ListTrafficPolicyInstancesRequest>
        Model::ListTrafficPolicyInstancesOutcomeCallable ListTrafficPolicyInstancesCallable(const ListTrafficPolicyInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&Route53Client::ListTrafficPolicyInstances, request);
        }
 
        template<typename ListTrafficPolicyInstancesRequestT = Model::ListTrafficPolicyInstancesRequest>
        void ListTrafficPolicyInstancesAsync(const ListTrafficPolicyInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTrafficPolicyInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&Route53Client::ListTrafficPolicyInstances, request, handler, context);
        }
 
        virtual Model::ListTrafficPolicyInstancesByHostedZoneOutcome ListTrafficPolicyInstancesByHostedZone(const Model::ListTrafficPolicyInstancesByHostedZoneRequest& request) const;
 
        template<typename ListTrafficPolicyInstancesByHostedZoneRequestT = Model::ListTrafficPolicyInstancesByHostedZoneRequest>
        Model::ListTrafficPolicyInstancesByHostedZoneOutcomeCallable ListTrafficPolicyInstancesByHostedZoneCallable(const ListTrafficPolicyInstancesByHostedZoneRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListTrafficPolicyInstancesByHostedZone, request);
        }
 
        template<typename ListTrafficPolicyInstancesByHostedZoneRequestT = Model::ListTrafficPolicyInstancesByHostedZoneRequest>
        void ListTrafficPolicyInstancesByHostedZoneAsync(const ListTrafficPolicyInstancesByHostedZoneRequestT& request, const ListTrafficPolicyInstancesByHostedZoneResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListTrafficPolicyInstancesByHostedZone, request, handler, context);
        }
 
        virtual Model::ListTrafficPolicyInstancesByPolicyOutcome ListTrafficPolicyInstancesByPolicy(const Model::ListTrafficPolicyInstancesByPolicyRequest& request) const;
 
        template<typename ListTrafficPolicyInstancesByPolicyRequestT = Model::ListTrafficPolicyInstancesByPolicyRequest>
        Model::ListTrafficPolicyInstancesByPolicyOutcomeCallable ListTrafficPolicyInstancesByPolicyCallable(const ListTrafficPolicyInstancesByPolicyRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListTrafficPolicyInstancesByPolicy, request);
        }
 
        template<typename ListTrafficPolicyInstancesByPolicyRequestT = Model::ListTrafficPolicyInstancesByPolicyRequest>
        void ListTrafficPolicyInstancesByPolicyAsync(const ListTrafficPolicyInstancesByPolicyRequestT& request, const ListTrafficPolicyInstancesByPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListTrafficPolicyInstancesByPolicy, request, handler, context);
        }
 
        virtual Model::ListTrafficPolicyVersionsOutcome ListTrafficPolicyVersions(const Model::ListTrafficPolicyVersionsRequest& request) const;
 
        template<typename ListTrafficPolicyVersionsRequestT = Model::ListTrafficPolicyVersionsRequest>
        Model::ListTrafficPolicyVersionsOutcomeCallable ListTrafficPolicyVersionsCallable(const ListTrafficPolicyVersionsRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListTrafficPolicyVersions, request);
        }
 
        template<typename ListTrafficPolicyVersionsRequestT = Model::ListTrafficPolicyVersionsRequest>
        void ListTrafficPolicyVersionsAsync(const ListTrafficPolicyVersionsRequestT& request, const ListTrafficPolicyVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListTrafficPolicyVersions, request, handler, context);
        }
 
        virtual Model::ListVPCAssociationAuthorizationsOutcome ListVPCAssociationAuthorizations(const Model::ListVPCAssociationAuthorizationsRequest& request) const;
 
        template<typename ListVPCAssociationAuthorizationsRequestT = Model::ListVPCAssociationAuthorizationsRequest>
        Model::ListVPCAssociationAuthorizationsOutcomeCallable ListVPCAssociationAuthorizationsCallable(const ListVPCAssociationAuthorizationsRequestT& request) const
        {
            return SubmitCallable(&Route53Client::ListVPCAssociationAuthorizations, request);
        }
 
        template<typename ListVPCAssociationAuthorizationsRequestT = Model::ListVPCAssociationAuthorizationsRequest>
        void ListVPCAssociationAuthorizationsAsync(const ListVPCAssociationAuthorizationsRequestT& request, const ListVPCAssociationAuthorizationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::ListVPCAssociationAuthorizations, request, handler, context);
        }
 
        virtual Model::TestDNSAnswerOutcome TestDNSAnswer(const Model::TestDNSAnswerRequest& request) const;
 
        template<typename TestDNSAnswerRequestT = Model::TestDNSAnswerRequest>
        Model::TestDNSAnswerOutcomeCallable TestDNSAnswerCallable(const TestDNSAnswerRequestT& request) const
        {
            return SubmitCallable(&Route53Client::TestDNSAnswer, request);
        }
 
        template<typename TestDNSAnswerRequestT = Model::TestDNSAnswerRequest>
        void TestDNSAnswerAsync(const TestDNSAnswerRequestT& request, const TestDNSAnswerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::TestDNSAnswer, request, handler, context);
        }
 
        virtual Model::UpdateHealthCheckOutcome UpdateHealthCheck(const Model::UpdateHealthCheckRequest& request) const;
 
        template<typename UpdateHealthCheckRequestT = Model::UpdateHealthCheckRequest>
        Model::UpdateHealthCheckOutcomeCallable UpdateHealthCheckCallable(const UpdateHealthCheckRequestT& request) const
        {
            return SubmitCallable(&Route53Client::UpdateHealthCheck, request);
        }
 
        template<typename UpdateHealthCheckRequestT = Model::UpdateHealthCheckRequest>
        void UpdateHealthCheckAsync(const UpdateHealthCheckRequestT& request, const UpdateHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::UpdateHealthCheck, request, handler, context);
        }
 
        virtual Model::UpdateHostedZoneCommentOutcome UpdateHostedZoneComment(const Model::UpdateHostedZoneCommentRequest& request) const;
 
        template<typename UpdateHostedZoneCommentRequestT = Model::UpdateHostedZoneCommentRequest>
        Model::UpdateHostedZoneCommentOutcomeCallable UpdateHostedZoneCommentCallable(const UpdateHostedZoneCommentRequestT& request) const
        {
            return SubmitCallable(&Route53Client::UpdateHostedZoneComment, request);
        }
 
        template<typename UpdateHostedZoneCommentRequestT = Model::UpdateHostedZoneCommentRequest>
        void UpdateHostedZoneCommentAsync(const UpdateHostedZoneCommentRequestT& request, const UpdateHostedZoneCommentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::UpdateHostedZoneComment, request, handler, context);
        }
 
        virtual Model::UpdateTrafficPolicyCommentOutcome UpdateTrafficPolicyComment(const Model::UpdateTrafficPolicyCommentRequest& request) const;
 
        template<typename UpdateTrafficPolicyCommentRequestT = Model::UpdateTrafficPolicyCommentRequest>
        Model::UpdateTrafficPolicyCommentOutcomeCallable UpdateTrafficPolicyCommentCallable(const UpdateTrafficPolicyCommentRequestT& request) const
        {
            return SubmitCallable(&Route53Client::UpdateTrafficPolicyComment, request);
        }
 
        template<typename UpdateTrafficPolicyCommentRequestT = Model::UpdateTrafficPolicyCommentRequest>
        void UpdateTrafficPolicyCommentAsync(const UpdateTrafficPolicyCommentRequestT& request, const UpdateTrafficPolicyCommentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::UpdateTrafficPolicyComment, request, handler, context);
        }
 
        virtual Model::UpdateTrafficPolicyInstanceOutcome UpdateTrafficPolicyInstance(const Model::UpdateTrafficPolicyInstanceRequest& request) const;
 
        template<typename UpdateTrafficPolicyInstanceRequestT = Model::UpdateTrafficPolicyInstanceRequest>
        Model::UpdateTrafficPolicyInstanceOutcomeCallable UpdateTrafficPolicyInstanceCallable(const UpdateTrafficPolicyInstanceRequestT& request) const
        {
            return SubmitCallable(&Route53Client::UpdateTrafficPolicyInstance, request);
        }
 
        template<typename UpdateTrafficPolicyInstanceRequestT = Model::UpdateTrafficPolicyInstanceRequest>
        void UpdateTrafficPolicyInstanceAsync(const UpdateTrafficPolicyInstanceRequestT& request, const UpdateTrafficPolicyInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53Client::UpdateTrafficPolicyInstance, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<Route53EndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53Client>;
        void init(const Route53ClientConfiguration& clientConfiguration);
 
        Route53ClientConfiguration m_clientConfiguration;
        std::shared_ptr<Route53EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Route53
} // namespace Aws