Route53Client.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/route53/Route53PaginationBase.h>
#include <aws/route53/Route53ServiceClientModel.h>
#include <aws/route53/Route53Waiter.h>
#include <aws/route53/Route53_EXPORTS.h>
 
namespace Aws {
namespace Route53 {
class AWS_ROUTE53_API Route53Client : public Aws::Client::AWSXMLClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<Route53Client>,
                                      public Route53PaginationBase<Route53Client>,
                                      public Route53Waiter<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::UpdateHostedZoneFeaturesOutcome UpdateHostedZoneFeatures(const Model::UpdateHostedZoneFeaturesRequest& request) const;
 
  template <typename UpdateHostedZoneFeaturesRequestT = Model::UpdateHostedZoneFeaturesRequest>
  Model::UpdateHostedZoneFeaturesOutcomeCallable UpdateHostedZoneFeaturesCallable(const UpdateHostedZoneFeaturesRequestT& request) const {
    return SubmitCallable(&Route53Client::UpdateHostedZoneFeatures, request);
  }
 
  template <typename UpdateHostedZoneFeaturesRequestT = Model::UpdateHostedZoneFeaturesRequest>
  void UpdateHostedZoneFeaturesAsync(const UpdateHostedZoneFeaturesRequestT& request,
                                     const UpdateHostedZoneFeaturesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53Client::UpdateHostedZoneFeatures, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Route53EndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53Client>;
  void init(const Route53ClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, Route53Error> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  Route53ClientConfiguration m_clientConfiguration;
  std::shared_ptr<Route53EndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Route53
}  // namespace Aws