Route53GlobalResolverClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/route53globalresolver/Route53GlobalResolverPaginationBase.h>
#include <aws/route53globalresolver/Route53GlobalResolverServiceClientModel.h>
#include <aws/route53globalresolver/Route53GlobalResolverWaiter.h>
#include <aws/route53globalresolver/Route53GlobalResolver_EXPORTS.h>
 
namespace Aws {
namespace Route53GlobalResolver {
class AWS_ROUTE53GLOBALRESOLVER_API Route53GlobalResolverClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<Route53GlobalResolverClient>,
      public Route53GlobalResolverPaginationBase<Route53GlobalResolverClient>,
      public Route53GlobalResolverWaiter<Route53GlobalResolverClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef Route53GlobalResolverClientConfiguration ClientConfigurationType;
  typedef Route53GlobalResolverEndpointProvider EndpointProviderType;
 
  Route53GlobalResolverClient(const Aws::Route53GlobalResolver::Route53GlobalResolverClientConfiguration& clientConfiguration =
                                  Aws::Route53GlobalResolver::Route53GlobalResolverClientConfiguration(),
                              std::shared_ptr<Route53GlobalResolverEndpointProviderBase> endpointProvider = nullptr);
 
  Route53GlobalResolverClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<Route53GlobalResolverEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::Route53GlobalResolver::Route53GlobalResolverClientConfiguration& clientConfiguration =
                                  Aws::Route53GlobalResolver::Route53GlobalResolverClientConfiguration());
 
  Route53GlobalResolverClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<Route53GlobalResolverEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::Route53GlobalResolver::Route53GlobalResolverClientConfiguration& clientConfiguration =
                                  Aws::Route53GlobalResolver::Route53GlobalResolverClientConfiguration());
 
  /* Legacy constructors due deprecation */
  Route53GlobalResolverClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Route53GlobalResolverClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Route53GlobalResolverClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~Route53GlobalResolverClient();
 
  virtual Model::AssociateHostedZoneOutcome AssociateHostedZone(const Model::AssociateHostedZoneRequest& request) const;
 
  template <typename AssociateHostedZoneRequestT = Model::AssociateHostedZoneRequest>
  Model::AssociateHostedZoneOutcomeCallable AssociateHostedZoneCallable(const AssociateHostedZoneRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::AssociateHostedZone, request);
  }
 
  template <typename AssociateHostedZoneRequestT = Model::AssociateHostedZoneRequest>
  void AssociateHostedZoneAsync(const AssociateHostedZoneRequestT& request, const AssociateHostedZoneResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::AssociateHostedZone, request, handler, context);
  }
 
  virtual Model::BatchCreateFirewallRuleOutcome BatchCreateFirewallRule(const Model::BatchCreateFirewallRuleRequest& request) const;
 
  template <typename BatchCreateFirewallRuleRequestT = Model::BatchCreateFirewallRuleRequest>
  Model::BatchCreateFirewallRuleOutcomeCallable BatchCreateFirewallRuleCallable(const BatchCreateFirewallRuleRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::BatchCreateFirewallRule, request);
  }
 
  template <typename BatchCreateFirewallRuleRequestT = Model::BatchCreateFirewallRuleRequest>
  void BatchCreateFirewallRuleAsync(const BatchCreateFirewallRuleRequestT& request,
                                    const BatchCreateFirewallRuleResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::BatchCreateFirewallRule, request, handler, context);
  }
 
  virtual Model::BatchDeleteFirewallRuleOutcome BatchDeleteFirewallRule(const Model::BatchDeleteFirewallRuleRequest& request) const;
 
  template <typename BatchDeleteFirewallRuleRequestT = Model::BatchDeleteFirewallRuleRequest>
  Model::BatchDeleteFirewallRuleOutcomeCallable BatchDeleteFirewallRuleCallable(const BatchDeleteFirewallRuleRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::BatchDeleteFirewallRule, request);
  }
 
  template <typename BatchDeleteFirewallRuleRequestT = Model::BatchDeleteFirewallRuleRequest>
  void BatchDeleteFirewallRuleAsync(const BatchDeleteFirewallRuleRequestT& request,
                                    const BatchDeleteFirewallRuleResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::BatchDeleteFirewallRule, request, handler, context);
  }
 
  virtual Model::BatchUpdateFirewallRuleOutcome BatchUpdateFirewallRule(const Model::BatchUpdateFirewallRuleRequest& request) const;
 
  template <typename BatchUpdateFirewallRuleRequestT = Model::BatchUpdateFirewallRuleRequest>
  Model::BatchUpdateFirewallRuleOutcomeCallable BatchUpdateFirewallRuleCallable(const BatchUpdateFirewallRuleRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::BatchUpdateFirewallRule, request);
  }
 
  template <typename BatchUpdateFirewallRuleRequestT = Model::BatchUpdateFirewallRuleRequest>
  void BatchUpdateFirewallRuleAsync(const BatchUpdateFirewallRuleRequestT& request,
                                    const BatchUpdateFirewallRuleResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::BatchUpdateFirewallRule, request, handler, context);
  }
 
  virtual Model::CreateAccessSourceOutcome CreateAccessSource(const Model::CreateAccessSourceRequest& request) const;
 
  template <typename CreateAccessSourceRequestT = Model::CreateAccessSourceRequest>
  Model::CreateAccessSourceOutcomeCallable CreateAccessSourceCallable(const CreateAccessSourceRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::CreateAccessSource, request);
  }
 
  template <typename CreateAccessSourceRequestT = Model::CreateAccessSourceRequest>
  void CreateAccessSourceAsync(const CreateAccessSourceRequestT& request, const CreateAccessSourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::CreateAccessSource, request, handler, context);
  }
 
  virtual Model::CreateAccessTokenOutcome CreateAccessToken(const Model::CreateAccessTokenRequest& request) const;
 
  template <typename CreateAccessTokenRequestT = Model::CreateAccessTokenRequest>
  Model::CreateAccessTokenOutcomeCallable CreateAccessTokenCallable(const CreateAccessTokenRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::CreateAccessToken, request);
  }
 
  template <typename CreateAccessTokenRequestT = Model::CreateAccessTokenRequest>
  void CreateAccessTokenAsync(const CreateAccessTokenRequestT& request, const CreateAccessTokenResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::CreateAccessToken, request, handler, context);
  }
 
  virtual Model::CreateDNSViewOutcome CreateDNSView(const Model::CreateDNSViewRequest& request) const;
 
  template <typename CreateDNSViewRequestT = Model::CreateDNSViewRequest>
  Model::CreateDNSViewOutcomeCallable CreateDNSViewCallable(const CreateDNSViewRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::CreateDNSView, request);
  }
 
  template <typename CreateDNSViewRequestT = Model::CreateDNSViewRequest>
  void CreateDNSViewAsync(const CreateDNSViewRequestT& request, const CreateDNSViewResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::CreateDNSView, request, handler, context);
  }
 
  virtual Model::CreateFirewallDomainListOutcome CreateFirewallDomainList(const Model::CreateFirewallDomainListRequest& request) const;
 
  template <typename CreateFirewallDomainListRequestT = Model::CreateFirewallDomainListRequest>
  Model::CreateFirewallDomainListOutcomeCallable CreateFirewallDomainListCallable(const CreateFirewallDomainListRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::CreateFirewallDomainList, request);
  }
 
  template <typename CreateFirewallDomainListRequestT = Model::CreateFirewallDomainListRequest>
  void CreateFirewallDomainListAsync(const CreateFirewallDomainListRequestT& request,
                                     const CreateFirewallDomainListResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::CreateFirewallDomainList, request, handler, context);
  }
 
  virtual Model::CreateFirewallRuleOutcome CreateFirewallRule(const Model::CreateFirewallRuleRequest& request) const;
 
  template <typename CreateFirewallRuleRequestT = Model::CreateFirewallRuleRequest>
  Model::CreateFirewallRuleOutcomeCallable CreateFirewallRuleCallable(const CreateFirewallRuleRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::CreateFirewallRule, request);
  }
 
  template <typename CreateFirewallRuleRequestT = Model::CreateFirewallRuleRequest>
  void CreateFirewallRuleAsync(const CreateFirewallRuleRequestT& request, const CreateFirewallRuleResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::CreateFirewallRule, request, handler, context);
  }
 
  virtual Model::CreateGlobalResolverOutcome CreateGlobalResolver(const Model::CreateGlobalResolverRequest& request) const;
 
  template <typename CreateGlobalResolverRequestT = Model::CreateGlobalResolverRequest>
  Model::CreateGlobalResolverOutcomeCallable CreateGlobalResolverCallable(const CreateGlobalResolverRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::CreateGlobalResolver, request);
  }
 
  template <typename CreateGlobalResolverRequestT = Model::CreateGlobalResolverRequest>
  void CreateGlobalResolverAsync(const CreateGlobalResolverRequestT& request, const CreateGlobalResolverResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::CreateGlobalResolver, request, handler, context);
  }
 
  virtual Model::DeleteAccessSourceOutcome DeleteAccessSource(const Model::DeleteAccessSourceRequest& request) const;
 
  template <typename DeleteAccessSourceRequestT = Model::DeleteAccessSourceRequest>
  Model::DeleteAccessSourceOutcomeCallable DeleteAccessSourceCallable(const DeleteAccessSourceRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DeleteAccessSource, request);
  }
 
  template <typename DeleteAccessSourceRequestT = Model::DeleteAccessSourceRequest>
  void DeleteAccessSourceAsync(const DeleteAccessSourceRequestT& request, const DeleteAccessSourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DeleteAccessSource, request, handler, context);
  }
 
  virtual Model::DeleteAccessTokenOutcome DeleteAccessToken(const Model::DeleteAccessTokenRequest& request) const;
 
  template <typename DeleteAccessTokenRequestT = Model::DeleteAccessTokenRequest>
  Model::DeleteAccessTokenOutcomeCallable DeleteAccessTokenCallable(const DeleteAccessTokenRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DeleteAccessToken, request);
  }
 
  template <typename DeleteAccessTokenRequestT = Model::DeleteAccessTokenRequest>
  void DeleteAccessTokenAsync(const DeleteAccessTokenRequestT& request, const DeleteAccessTokenResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DeleteAccessToken, request, handler, context);
  }
 
  virtual Model::DeleteDNSViewOutcome DeleteDNSView(const Model::DeleteDNSViewRequest& request) const;
 
  template <typename DeleteDNSViewRequestT = Model::DeleteDNSViewRequest>
  Model::DeleteDNSViewOutcomeCallable DeleteDNSViewCallable(const DeleteDNSViewRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DeleteDNSView, request);
  }
 
  template <typename DeleteDNSViewRequestT = Model::DeleteDNSViewRequest>
  void DeleteDNSViewAsync(const DeleteDNSViewRequestT& request, const DeleteDNSViewResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DeleteDNSView, request, handler, context);
  }
 
  virtual Model::DeleteFirewallDomainListOutcome DeleteFirewallDomainList(const Model::DeleteFirewallDomainListRequest& request) const;
 
  template <typename DeleteFirewallDomainListRequestT = Model::DeleteFirewallDomainListRequest>
  Model::DeleteFirewallDomainListOutcomeCallable DeleteFirewallDomainListCallable(const DeleteFirewallDomainListRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DeleteFirewallDomainList, request);
  }
 
  template <typename DeleteFirewallDomainListRequestT = Model::DeleteFirewallDomainListRequest>
  void DeleteFirewallDomainListAsync(const DeleteFirewallDomainListRequestT& request,
                                     const DeleteFirewallDomainListResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DeleteFirewallDomainList, request, handler, context);
  }
 
  virtual Model::DeleteFirewallRuleOutcome DeleteFirewallRule(const Model::DeleteFirewallRuleRequest& request) const;
 
  template <typename DeleteFirewallRuleRequestT = Model::DeleteFirewallRuleRequest>
  Model::DeleteFirewallRuleOutcomeCallable DeleteFirewallRuleCallable(const DeleteFirewallRuleRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DeleteFirewallRule, request);
  }
 
  template <typename DeleteFirewallRuleRequestT = Model::DeleteFirewallRuleRequest>
  void DeleteFirewallRuleAsync(const DeleteFirewallRuleRequestT& request, const DeleteFirewallRuleResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DeleteFirewallRule, request, handler, context);
  }
 
  virtual Model::DeleteGlobalResolverOutcome DeleteGlobalResolver(const Model::DeleteGlobalResolverRequest& request) const;
 
  template <typename DeleteGlobalResolverRequestT = Model::DeleteGlobalResolverRequest>
  Model::DeleteGlobalResolverOutcomeCallable DeleteGlobalResolverCallable(const DeleteGlobalResolverRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DeleteGlobalResolver, request);
  }
 
  template <typename DeleteGlobalResolverRequestT = Model::DeleteGlobalResolverRequest>
  void DeleteGlobalResolverAsync(const DeleteGlobalResolverRequestT& request, const DeleteGlobalResolverResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DeleteGlobalResolver, request, handler, context);
  }
 
  virtual Model::DisableDNSViewOutcome DisableDNSView(const Model::DisableDNSViewRequest& request) const;
 
  template <typename DisableDNSViewRequestT = Model::DisableDNSViewRequest>
  Model::DisableDNSViewOutcomeCallable DisableDNSViewCallable(const DisableDNSViewRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DisableDNSView, request);
  }
 
  template <typename DisableDNSViewRequestT = Model::DisableDNSViewRequest>
  void DisableDNSViewAsync(const DisableDNSViewRequestT& request, const DisableDNSViewResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DisableDNSView, request, handler, context);
  }
 
  virtual Model::DisassociateHostedZoneOutcome DisassociateHostedZone(const Model::DisassociateHostedZoneRequest& request) const;
 
  template <typename DisassociateHostedZoneRequestT = Model::DisassociateHostedZoneRequest>
  Model::DisassociateHostedZoneOutcomeCallable DisassociateHostedZoneCallable(const DisassociateHostedZoneRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::DisassociateHostedZone, request);
  }
 
  template <typename DisassociateHostedZoneRequestT = Model::DisassociateHostedZoneRequest>
  void DisassociateHostedZoneAsync(const DisassociateHostedZoneRequestT& request,
                                   const DisassociateHostedZoneResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::DisassociateHostedZone, request, handler, context);
  }
 
  virtual Model::EnableDNSViewOutcome EnableDNSView(const Model::EnableDNSViewRequest& request) const;
 
  template <typename EnableDNSViewRequestT = Model::EnableDNSViewRequest>
  Model::EnableDNSViewOutcomeCallable EnableDNSViewCallable(const EnableDNSViewRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::EnableDNSView, request);
  }
 
  template <typename EnableDNSViewRequestT = Model::EnableDNSViewRequest>
  void EnableDNSViewAsync(const EnableDNSViewRequestT& request, const EnableDNSViewResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::EnableDNSView, request, handler, context);
  }
 
  virtual Model::GetAccessSourceOutcome GetAccessSource(const Model::GetAccessSourceRequest& request) const;
 
  template <typename GetAccessSourceRequestT = Model::GetAccessSourceRequest>
  Model::GetAccessSourceOutcomeCallable GetAccessSourceCallable(const GetAccessSourceRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetAccessSource, request);
  }
 
  template <typename GetAccessSourceRequestT = Model::GetAccessSourceRequest>
  void GetAccessSourceAsync(const GetAccessSourceRequestT& request, const GetAccessSourceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetAccessSource, request, handler, context);
  }
 
  virtual Model::GetAccessTokenOutcome GetAccessToken(const Model::GetAccessTokenRequest& request) const;
 
  template <typename GetAccessTokenRequestT = Model::GetAccessTokenRequest>
  Model::GetAccessTokenOutcomeCallable GetAccessTokenCallable(const GetAccessTokenRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetAccessToken, request);
  }
 
  template <typename GetAccessTokenRequestT = Model::GetAccessTokenRequest>
  void GetAccessTokenAsync(const GetAccessTokenRequestT& request, const GetAccessTokenResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetAccessToken, request, handler, context);
  }
 
  virtual Model::GetDNSViewOutcome GetDNSView(const Model::GetDNSViewRequest& request) const;
 
  template <typename GetDNSViewRequestT = Model::GetDNSViewRequest>
  Model::GetDNSViewOutcomeCallable GetDNSViewCallable(const GetDNSViewRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetDNSView, request);
  }
 
  template <typename GetDNSViewRequestT = Model::GetDNSViewRequest>
  void GetDNSViewAsync(const GetDNSViewRequestT& request, const GetDNSViewResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetDNSView, request, handler, context);
  }
 
  virtual Model::GetFirewallDomainListOutcome GetFirewallDomainList(const Model::GetFirewallDomainListRequest& request) const;
 
  template <typename GetFirewallDomainListRequestT = Model::GetFirewallDomainListRequest>
  Model::GetFirewallDomainListOutcomeCallable GetFirewallDomainListCallable(const GetFirewallDomainListRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetFirewallDomainList, request);
  }
 
  template <typename GetFirewallDomainListRequestT = Model::GetFirewallDomainListRequest>
  void GetFirewallDomainListAsync(const GetFirewallDomainListRequestT& request, const GetFirewallDomainListResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetFirewallDomainList, request, handler, context);
  }
 
  virtual Model::GetFirewallRuleOutcome GetFirewallRule(const Model::GetFirewallRuleRequest& request) const;
 
  template <typename GetFirewallRuleRequestT = Model::GetFirewallRuleRequest>
  Model::GetFirewallRuleOutcomeCallable GetFirewallRuleCallable(const GetFirewallRuleRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetFirewallRule, request);
  }
 
  template <typename GetFirewallRuleRequestT = Model::GetFirewallRuleRequest>
  void GetFirewallRuleAsync(const GetFirewallRuleRequestT& request, const GetFirewallRuleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetFirewallRule, request, handler, context);
  }
 
  virtual Model::GetGlobalResolverOutcome GetGlobalResolver(const Model::GetGlobalResolverRequest& request) const;
 
  template <typename GetGlobalResolverRequestT = Model::GetGlobalResolverRequest>
  Model::GetGlobalResolverOutcomeCallable GetGlobalResolverCallable(const GetGlobalResolverRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetGlobalResolver, request);
  }
 
  template <typename GetGlobalResolverRequestT = Model::GetGlobalResolverRequest>
  void GetGlobalResolverAsync(const GetGlobalResolverRequestT& request, const GetGlobalResolverResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetGlobalResolver, request, handler, context);
  }
 
  virtual Model::GetHostedZoneAssociationOutcome GetHostedZoneAssociation(const Model::GetHostedZoneAssociationRequest& request) const;
 
  template <typename GetHostedZoneAssociationRequestT = Model::GetHostedZoneAssociationRequest>
  Model::GetHostedZoneAssociationOutcomeCallable GetHostedZoneAssociationCallable(const GetHostedZoneAssociationRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetHostedZoneAssociation, request);
  }
 
  template <typename GetHostedZoneAssociationRequestT = Model::GetHostedZoneAssociationRequest>
  void GetHostedZoneAssociationAsync(const GetHostedZoneAssociationRequestT& request,
                                     const GetHostedZoneAssociationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetHostedZoneAssociation, request, handler, context);
  }
 
  virtual Model::GetManagedFirewallDomainListOutcome GetManagedFirewallDomainList(
      const Model::GetManagedFirewallDomainListRequest& request) const;
 
  template <typename GetManagedFirewallDomainListRequestT = Model::GetManagedFirewallDomainListRequest>
  Model::GetManagedFirewallDomainListOutcomeCallable GetManagedFirewallDomainListCallable(
      const GetManagedFirewallDomainListRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::GetManagedFirewallDomainList, request);
  }
 
  template <typename GetManagedFirewallDomainListRequestT = Model::GetManagedFirewallDomainListRequest>
  void GetManagedFirewallDomainListAsync(const GetManagedFirewallDomainListRequestT& request,
                                         const GetManagedFirewallDomainListResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::GetManagedFirewallDomainList, request, handler, context);
  }
 
  virtual Model::ImportFirewallDomainsOutcome ImportFirewallDomains(const Model::ImportFirewallDomainsRequest& request) const;
 
  template <typename ImportFirewallDomainsRequestT = Model::ImportFirewallDomainsRequest>
  Model::ImportFirewallDomainsOutcomeCallable ImportFirewallDomainsCallable(const ImportFirewallDomainsRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::ImportFirewallDomains, request);
  }
 
  template <typename ImportFirewallDomainsRequestT = Model::ImportFirewallDomainsRequest>
  void ImportFirewallDomainsAsync(const ImportFirewallDomainsRequestT& request, const ImportFirewallDomainsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::ImportFirewallDomains, request, handler, context);
  }
 
  virtual Model::ListAccessSourcesOutcome ListAccessSources(const Model::ListAccessSourcesRequest& request = {}) const;
 
  template <typename ListAccessSourcesRequestT = Model::ListAccessSourcesRequest>
  Model::ListAccessSourcesOutcomeCallable ListAccessSourcesCallable(const ListAccessSourcesRequestT& request = {}) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListAccessSources, request);
  }
 
  template <typename ListAccessSourcesRequestT = Model::ListAccessSourcesRequest>
  void ListAccessSourcesAsync(const ListAccessSourcesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListAccessSourcesRequestT& request = {}) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListAccessSources, request, handler, context);
  }
 
  virtual Model::ListAccessTokensOutcome ListAccessTokens(const Model::ListAccessTokensRequest& request) const;
 
  template <typename ListAccessTokensRequestT = Model::ListAccessTokensRequest>
  Model::ListAccessTokensOutcomeCallable ListAccessTokensCallable(const ListAccessTokensRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListAccessTokens, request);
  }
 
  template <typename ListAccessTokensRequestT = Model::ListAccessTokensRequest>
  void ListAccessTokensAsync(const ListAccessTokensRequestT& request, const ListAccessTokensResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListAccessTokens, request, handler, context);
  }
 
  virtual Model::ListDNSViewsOutcome ListDNSViews(const Model::ListDNSViewsRequest& request) const;
 
  template <typename ListDNSViewsRequestT = Model::ListDNSViewsRequest>
  Model::ListDNSViewsOutcomeCallable ListDNSViewsCallable(const ListDNSViewsRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListDNSViews, request);
  }
 
  template <typename ListDNSViewsRequestT = Model::ListDNSViewsRequest>
  void ListDNSViewsAsync(const ListDNSViewsRequestT& request, const ListDNSViewsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListDNSViews, request, handler, context);
  }
 
  virtual Model::ListFirewallDomainListsOutcome ListFirewallDomainLists(const Model::ListFirewallDomainListsRequest& request = {}) const;
 
  template <typename ListFirewallDomainListsRequestT = Model::ListFirewallDomainListsRequest>
  Model::ListFirewallDomainListsOutcomeCallable ListFirewallDomainListsCallable(const ListFirewallDomainListsRequestT& request = {}) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListFirewallDomainLists, request);
  }
 
  template <typename ListFirewallDomainListsRequestT = Model::ListFirewallDomainListsRequest>
  void ListFirewallDomainListsAsync(const ListFirewallDomainListsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListFirewallDomainListsRequestT& request = {}) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListFirewallDomainLists, request, handler, context);
  }
 
  virtual Model::ListFirewallDomainsOutcome ListFirewallDomains(const Model::ListFirewallDomainsRequest& request) const;
 
  template <typename ListFirewallDomainsRequestT = Model::ListFirewallDomainsRequest>
  Model::ListFirewallDomainsOutcomeCallable ListFirewallDomainsCallable(const ListFirewallDomainsRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListFirewallDomains, request);
  }
 
  template <typename ListFirewallDomainsRequestT = Model::ListFirewallDomainsRequest>
  void ListFirewallDomainsAsync(const ListFirewallDomainsRequestT& request, const ListFirewallDomainsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListFirewallDomains, request, handler, context);
  }
 
  virtual Model::ListFirewallRulesOutcome ListFirewallRules(const Model::ListFirewallRulesRequest& request) const;
 
  template <typename ListFirewallRulesRequestT = Model::ListFirewallRulesRequest>
  Model::ListFirewallRulesOutcomeCallable ListFirewallRulesCallable(const ListFirewallRulesRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListFirewallRules, request);
  }
 
  template <typename ListFirewallRulesRequestT = Model::ListFirewallRulesRequest>
  void ListFirewallRulesAsync(const ListFirewallRulesRequestT& request, const ListFirewallRulesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListFirewallRules, request, handler, context);
  }
 
  virtual Model::ListGlobalResolversOutcome ListGlobalResolvers(const Model::ListGlobalResolversRequest& request = {}) const;
 
  template <typename ListGlobalResolversRequestT = Model::ListGlobalResolversRequest>
  Model::ListGlobalResolversOutcomeCallable ListGlobalResolversCallable(const ListGlobalResolversRequestT& request = {}) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListGlobalResolvers, request);
  }
 
  template <typename ListGlobalResolversRequestT = Model::ListGlobalResolversRequest>
  void ListGlobalResolversAsync(const ListGlobalResolversResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListGlobalResolversRequestT& request = {}) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListGlobalResolvers, request, handler, context);
  }
 
  virtual Model::ListHostedZoneAssociationsOutcome ListHostedZoneAssociations(
      const Model::ListHostedZoneAssociationsRequest& request) const;
 
  template <typename ListHostedZoneAssociationsRequestT = Model::ListHostedZoneAssociationsRequest>
  Model::ListHostedZoneAssociationsOutcomeCallable ListHostedZoneAssociationsCallable(
      const ListHostedZoneAssociationsRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListHostedZoneAssociations, request);
  }
 
  template <typename ListHostedZoneAssociationsRequestT = Model::ListHostedZoneAssociationsRequest>
  void ListHostedZoneAssociationsAsync(const ListHostedZoneAssociationsRequestT& request,
                                       const ListHostedZoneAssociationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListHostedZoneAssociations, request, handler, context);
  }
 
  virtual Model::ListManagedFirewallDomainListsOutcome ListManagedFirewallDomainLists(
      const Model::ListManagedFirewallDomainListsRequest& request) const;
 
  template <typename ListManagedFirewallDomainListsRequestT = Model::ListManagedFirewallDomainListsRequest>
  Model::ListManagedFirewallDomainListsOutcomeCallable ListManagedFirewallDomainListsCallable(
      const ListManagedFirewallDomainListsRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::ListManagedFirewallDomainLists, request);
  }
 
  template <typename ListManagedFirewallDomainListsRequestT = Model::ListManagedFirewallDomainListsRequest>
  void ListManagedFirewallDomainListsAsync(const ListManagedFirewallDomainListsRequestT& request,
                                           const ListManagedFirewallDomainListsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::ListManagedFirewallDomainLists, 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(&Route53GlobalResolverClient::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(&Route53GlobalResolverClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAccessSourceOutcome UpdateAccessSource(const Model::UpdateAccessSourceRequest& request) const;
 
  template <typename UpdateAccessSourceRequestT = Model::UpdateAccessSourceRequest>
  Model::UpdateAccessSourceOutcomeCallable UpdateAccessSourceCallable(const UpdateAccessSourceRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UpdateAccessSource, request);
  }
 
  template <typename UpdateAccessSourceRequestT = Model::UpdateAccessSourceRequest>
  void UpdateAccessSourceAsync(const UpdateAccessSourceRequestT& request, const UpdateAccessSourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UpdateAccessSource, request, handler, context);
  }
 
  virtual Model::UpdateAccessTokenOutcome UpdateAccessToken(const Model::UpdateAccessTokenRequest& request) const;
 
  template <typename UpdateAccessTokenRequestT = Model::UpdateAccessTokenRequest>
  Model::UpdateAccessTokenOutcomeCallable UpdateAccessTokenCallable(const UpdateAccessTokenRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UpdateAccessToken, request);
  }
 
  template <typename UpdateAccessTokenRequestT = Model::UpdateAccessTokenRequest>
  void UpdateAccessTokenAsync(const UpdateAccessTokenRequestT& request, const UpdateAccessTokenResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UpdateAccessToken, request, handler, context);
  }
 
  virtual Model::UpdateDNSViewOutcome UpdateDNSView(const Model::UpdateDNSViewRequest& request) const;
 
  template <typename UpdateDNSViewRequestT = Model::UpdateDNSViewRequest>
  Model::UpdateDNSViewOutcomeCallable UpdateDNSViewCallable(const UpdateDNSViewRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UpdateDNSView, request);
  }
 
  template <typename UpdateDNSViewRequestT = Model::UpdateDNSViewRequest>
  void UpdateDNSViewAsync(const UpdateDNSViewRequestT& request, const UpdateDNSViewResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UpdateDNSView, request, handler, context);
  }
 
  virtual Model::UpdateFirewallDomainsOutcome UpdateFirewallDomains(const Model::UpdateFirewallDomainsRequest& request) const;
 
  template <typename UpdateFirewallDomainsRequestT = Model::UpdateFirewallDomainsRequest>
  Model::UpdateFirewallDomainsOutcomeCallable UpdateFirewallDomainsCallable(const UpdateFirewallDomainsRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UpdateFirewallDomains, request);
  }
 
  template <typename UpdateFirewallDomainsRequestT = Model::UpdateFirewallDomainsRequest>
  void UpdateFirewallDomainsAsync(const UpdateFirewallDomainsRequestT& request, const UpdateFirewallDomainsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UpdateFirewallDomains, request, handler, context);
  }
 
  virtual Model::UpdateFirewallRuleOutcome UpdateFirewallRule(const Model::UpdateFirewallRuleRequest& request) const;
 
  template <typename UpdateFirewallRuleRequestT = Model::UpdateFirewallRuleRequest>
  Model::UpdateFirewallRuleOutcomeCallable UpdateFirewallRuleCallable(const UpdateFirewallRuleRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UpdateFirewallRule, request);
  }
 
  template <typename UpdateFirewallRuleRequestT = Model::UpdateFirewallRuleRequest>
  void UpdateFirewallRuleAsync(const UpdateFirewallRuleRequestT& request, const UpdateFirewallRuleResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UpdateFirewallRule, request, handler, context);
  }
 
  virtual Model::UpdateGlobalResolverOutcome UpdateGlobalResolver(const Model::UpdateGlobalResolverRequest& request) const;
 
  template <typename UpdateGlobalResolverRequestT = Model::UpdateGlobalResolverRequest>
  Model::UpdateGlobalResolverOutcomeCallable UpdateGlobalResolverCallable(const UpdateGlobalResolverRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UpdateGlobalResolver, request);
  }
 
  template <typename UpdateGlobalResolverRequestT = Model::UpdateGlobalResolverRequest>
  void UpdateGlobalResolverAsync(const UpdateGlobalResolverRequestT& request, const UpdateGlobalResolverResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UpdateGlobalResolver, request, handler, context);
  }
 
  virtual Model::UpdateHostedZoneAssociationOutcome UpdateHostedZoneAssociation(
      const Model::UpdateHostedZoneAssociationRequest& request) const;
 
  template <typename UpdateHostedZoneAssociationRequestT = Model::UpdateHostedZoneAssociationRequest>
  Model::UpdateHostedZoneAssociationOutcomeCallable UpdateHostedZoneAssociationCallable(
      const UpdateHostedZoneAssociationRequestT& request) const {
    return SubmitCallable(&Route53GlobalResolverClient::UpdateHostedZoneAssociation, request);
  }
 
  template <typename UpdateHostedZoneAssociationRequestT = Model::UpdateHostedZoneAssociationRequest>
  void UpdateHostedZoneAssociationAsync(const UpdateHostedZoneAssociationRequestT& request,
                                        const UpdateHostedZoneAssociationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53GlobalResolverClient::UpdateHostedZoneAssociation, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Route53GlobalResolverEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53GlobalResolverClient>;
  void init(const Route53GlobalResolverClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, Route53GlobalResolverError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  Route53GlobalResolverClientConfiguration m_clientConfiguration;
  std::shared_ptr<Route53GlobalResolverEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Route53GlobalResolver
}  // namespace Aws