Route53ResolverClient.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/route53resolver/Route53ResolverServiceClientModel.h>
#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
 
namespace Aws {
namespace Route53Resolver {
class AWS_ROUTE53RESOLVER_API Route53ResolverClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<Route53ResolverClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef Route53ResolverClientConfiguration ClientConfigurationType;
  typedef Route53ResolverEndpointProvider EndpointProviderType;
 
  Route53ResolverClient(const Aws::Route53Resolver::Route53ResolverClientConfiguration& clientConfiguration =
                            Aws::Route53Resolver::Route53ResolverClientConfiguration(),
                        std::shared_ptr<Route53ResolverEndpointProviderBase> endpointProvider = nullptr);
 
  Route53ResolverClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<Route53ResolverEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::Route53Resolver::Route53ResolverClientConfiguration& clientConfiguration =
                            Aws::Route53Resolver::Route53ResolverClientConfiguration());
 
  Route53ResolverClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<Route53ResolverEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::Route53Resolver::Route53ResolverClientConfiguration& clientConfiguration =
                            Aws::Route53Resolver::Route53ResolverClientConfiguration());
 
  /* Legacy constructors due deprecation */
  Route53ResolverClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Route53ResolverClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  Route53ResolverClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~Route53ResolverClient();
 
  virtual Model::AssociateFirewallRuleGroupOutcome AssociateFirewallRuleGroup(
      const Model::AssociateFirewallRuleGroupRequest& request) const;
 
  template <typename AssociateFirewallRuleGroupRequestT = Model::AssociateFirewallRuleGroupRequest>
  Model::AssociateFirewallRuleGroupOutcomeCallable AssociateFirewallRuleGroupCallable(
      const AssociateFirewallRuleGroupRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::AssociateFirewallRuleGroup, request);
  }
 
  template <typename AssociateFirewallRuleGroupRequestT = Model::AssociateFirewallRuleGroupRequest>
  void AssociateFirewallRuleGroupAsync(const AssociateFirewallRuleGroupRequestT& request,
                                       const AssociateFirewallRuleGroupResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::AssociateFirewallRuleGroup, request, handler, context);
  }
 
  virtual Model::AssociateResolverEndpointIpAddressOutcome AssociateResolverEndpointIpAddress(
      const Model::AssociateResolverEndpointIpAddressRequest& request) const;
 
  template <typename AssociateResolverEndpointIpAddressRequestT = Model::AssociateResolverEndpointIpAddressRequest>
  Model::AssociateResolverEndpointIpAddressOutcomeCallable AssociateResolverEndpointIpAddressCallable(
      const AssociateResolverEndpointIpAddressRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::AssociateResolverEndpointIpAddress, request);
  }
 
  template <typename AssociateResolverEndpointIpAddressRequestT = Model::AssociateResolverEndpointIpAddressRequest>
  void AssociateResolverEndpointIpAddressAsync(const AssociateResolverEndpointIpAddressRequestT& request,
                                               const AssociateResolverEndpointIpAddressResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::AssociateResolverEndpointIpAddress, request, handler, context);
  }
 
  virtual Model::AssociateResolverQueryLogConfigOutcome AssociateResolverQueryLogConfig(
      const Model::AssociateResolverQueryLogConfigRequest& request) const;
 
  template <typename AssociateResolverQueryLogConfigRequestT = Model::AssociateResolverQueryLogConfigRequest>
  Model::AssociateResolverQueryLogConfigOutcomeCallable AssociateResolverQueryLogConfigCallable(
      const AssociateResolverQueryLogConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::AssociateResolverQueryLogConfig, request);
  }
 
  template <typename AssociateResolverQueryLogConfigRequestT = Model::AssociateResolverQueryLogConfigRequest>
  void AssociateResolverQueryLogConfigAsync(const AssociateResolverQueryLogConfigRequestT& request,
                                            const AssociateResolverQueryLogConfigResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::AssociateResolverQueryLogConfig, request, handler, context);
  }
 
  virtual Model::AssociateResolverRuleOutcome AssociateResolverRule(const Model::AssociateResolverRuleRequest& request) const;
 
  template <typename AssociateResolverRuleRequestT = Model::AssociateResolverRuleRequest>
  Model::AssociateResolverRuleOutcomeCallable AssociateResolverRuleCallable(const AssociateResolverRuleRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::AssociateResolverRule, request);
  }
 
  template <typename AssociateResolverRuleRequestT = Model::AssociateResolverRuleRequest>
  void AssociateResolverRuleAsync(const AssociateResolverRuleRequestT& request, const AssociateResolverRuleResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::AssociateResolverRule, 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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::CreateFirewallRule, request, handler, context);
  }
 
  virtual Model::CreateFirewallRuleGroupOutcome CreateFirewallRuleGroup(const Model::CreateFirewallRuleGroupRequest& request) const;
 
  template <typename CreateFirewallRuleGroupRequestT = Model::CreateFirewallRuleGroupRequest>
  Model::CreateFirewallRuleGroupOutcomeCallable CreateFirewallRuleGroupCallable(const CreateFirewallRuleGroupRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::CreateFirewallRuleGroup, request);
  }
 
  template <typename CreateFirewallRuleGroupRequestT = Model::CreateFirewallRuleGroupRequest>
  void CreateFirewallRuleGroupAsync(const CreateFirewallRuleGroupRequestT& request,
                                    const CreateFirewallRuleGroupResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::CreateFirewallRuleGroup, request, handler, context);
  }
 
  virtual Model::CreateOutpostResolverOutcome CreateOutpostResolver(const Model::CreateOutpostResolverRequest& request) const;
 
  template <typename CreateOutpostResolverRequestT = Model::CreateOutpostResolverRequest>
  Model::CreateOutpostResolverOutcomeCallable CreateOutpostResolverCallable(const CreateOutpostResolverRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::CreateOutpostResolver, request);
  }
 
  template <typename CreateOutpostResolverRequestT = Model::CreateOutpostResolverRequest>
  void CreateOutpostResolverAsync(const CreateOutpostResolverRequestT& request, const CreateOutpostResolverResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::CreateOutpostResolver, request, handler, context);
  }
 
  virtual Model::CreateResolverEndpointOutcome CreateResolverEndpoint(const Model::CreateResolverEndpointRequest& request) const;
 
  template <typename CreateResolverEndpointRequestT = Model::CreateResolverEndpointRequest>
  Model::CreateResolverEndpointOutcomeCallable CreateResolverEndpointCallable(const CreateResolverEndpointRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::CreateResolverEndpoint, request);
  }
 
  template <typename CreateResolverEndpointRequestT = Model::CreateResolverEndpointRequest>
  void CreateResolverEndpointAsync(const CreateResolverEndpointRequestT& request,
                                   const CreateResolverEndpointResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::CreateResolverEndpoint, request, handler, context);
  }
 
  virtual Model::CreateResolverQueryLogConfigOutcome CreateResolverQueryLogConfig(
      const Model::CreateResolverQueryLogConfigRequest& request) const;
 
  template <typename CreateResolverQueryLogConfigRequestT = Model::CreateResolverQueryLogConfigRequest>
  Model::CreateResolverQueryLogConfigOutcomeCallable CreateResolverQueryLogConfigCallable(
      const CreateResolverQueryLogConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::CreateResolverQueryLogConfig, request);
  }
 
  template <typename CreateResolverQueryLogConfigRequestT = Model::CreateResolverQueryLogConfigRequest>
  void CreateResolverQueryLogConfigAsync(const CreateResolverQueryLogConfigRequestT& request,
                                         const CreateResolverQueryLogConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::CreateResolverQueryLogConfig, request, handler, context);
  }
 
  virtual Model::CreateResolverRuleOutcome CreateResolverRule(const Model::CreateResolverRuleRequest& request) const;
 
  template <typename CreateResolverRuleRequestT = Model::CreateResolverRuleRequest>
  Model::CreateResolverRuleOutcomeCallable CreateResolverRuleCallable(const CreateResolverRuleRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::CreateResolverRule, request);
  }
 
  template <typename CreateResolverRuleRequestT = Model::CreateResolverRuleRequest>
  void CreateResolverRuleAsync(const CreateResolverRuleRequestT& request, const CreateResolverRuleResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::CreateResolverRule, 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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::DeleteFirewallRule, request, handler, context);
  }
 
  virtual Model::DeleteFirewallRuleGroupOutcome DeleteFirewallRuleGroup(const Model::DeleteFirewallRuleGroupRequest& request) const;
 
  template <typename DeleteFirewallRuleGroupRequestT = Model::DeleteFirewallRuleGroupRequest>
  Model::DeleteFirewallRuleGroupOutcomeCallable DeleteFirewallRuleGroupCallable(const DeleteFirewallRuleGroupRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DeleteFirewallRuleGroup, request);
  }
 
  template <typename DeleteFirewallRuleGroupRequestT = Model::DeleteFirewallRuleGroupRequest>
  void DeleteFirewallRuleGroupAsync(const DeleteFirewallRuleGroupRequestT& request,
                                    const DeleteFirewallRuleGroupResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DeleteFirewallRuleGroup, request, handler, context);
  }
 
  virtual Model::DeleteOutpostResolverOutcome DeleteOutpostResolver(const Model::DeleteOutpostResolverRequest& request) const;
 
  template <typename DeleteOutpostResolverRequestT = Model::DeleteOutpostResolverRequest>
  Model::DeleteOutpostResolverOutcomeCallable DeleteOutpostResolverCallable(const DeleteOutpostResolverRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DeleteOutpostResolver, request);
  }
 
  template <typename DeleteOutpostResolverRequestT = Model::DeleteOutpostResolverRequest>
  void DeleteOutpostResolverAsync(const DeleteOutpostResolverRequestT& request, const DeleteOutpostResolverResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DeleteOutpostResolver, request, handler, context);
  }
 
  virtual Model::DeleteResolverEndpointOutcome DeleteResolverEndpoint(const Model::DeleteResolverEndpointRequest& request) const;
 
  template <typename DeleteResolverEndpointRequestT = Model::DeleteResolverEndpointRequest>
  Model::DeleteResolverEndpointOutcomeCallable DeleteResolverEndpointCallable(const DeleteResolverEndpointRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DeleteResolverEndpoint, request);
  }
 
  template <typename DeleteResolverEndpointRequestT = Model::DeleteResolverEndpointRequest>
  void DeleteResolverEndpointAsync(const DeleteResolverEndpointRequestT& request,
                                   const DeleteResolverEndpointResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DeleteResolverEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteResolverQueryLogConfigOutcome DeleteResolverQueryLogConfig(
      const Model::DeleteResolverQueryLogConfigRequest& request) const;
 
  template <typename DeleteResolverQueryLogConfigRequestT = Model::DeleteResolverQueryLogConfigRequest>
  Model::DeleteResolverQueryLogConfigOutcomeCallable DeleteResolverQueryLogConfigCallable(
      const DeleteResolverQueryLogConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DeleteResolverQueryLogConfig, request);
  }
 
  template <typename DeleteResolverQueryLogConfigRequestT = Model::DeleteResolverQueryLogConfigRequest>
  void DeleteResolverQueryLogConfigAsync(const DeleteResolverQueryLogConfigRequestT& request,
                                         const DeleteResolverQueryLogConfigResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DeleteResolverQueryLogConfig, request, handler, context);
  }
 
  virtual Model::DeleteResolverRuleOutcome DeleteResolverRule(const Model::DeleteResolverRuleRequest& request) const;
 
  template <typename DeleteResolverRuleRequestT = Model::DeleteResolverRuleRequest>
  Model::DeleteResolverRuleOutcomeCallable DeleteResolverRuleCallable(const DeleteResolverRuleRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DeleteResolverRule, request);
  }
 
  template <typename DeleteResolverRuleRequestT = Model::DeleteResolverRuleRequest>
  void DeleteResolverRuleAsync(const DeleteResolverRuleRequestT& request, const DeleteResolverRuleResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DeleteResolverRule, request, handler, context);
  }
 
  virtual Model::DisassociateFirewallRuleGroupOutcome DisassociateFirewallRuleGroup(
      const Model::DisassociateFirewallRuleGroupRequest& request) const;
 
  template <typename DisassociateFirewallRuleGroupRequestT = Model::DisassociateFirewallRuleGroupRequest>
  Model::DisassociateFirewallRuleGroupOutcomeCallable DisassociateFirewallRuleGroupCallable(
      const DisassociateFirewallRuleGroupRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DisassociateFirewallRuleGroup, request);
  }
 
  template <typename DisassociateFirewallRuleGroupRequestT = Model::DisassociateFirewallRuleGroupRequest>
  void DisassociateFirewallRuleGroupAsync(const DisassociateFirewallRuleGroupRequestT& request,
                                          const DisassociateFirewallRuleGroupResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DisassociateFirewallRuleGroup, request, handler, context);
  }
 
  virtual Model::DisassociateResolverEndpointIpAddressOutcome DisassociateResolverEndpointIpAddress(
      const Model::DisassociateResolverEndpointIpAddressRequest& request) const;
 
  template <typename DisassociateResolverEndpointIpAddressRequestT = Model::DisassociateResolverEndpointIpAddressRequest>
  Model::DisassociateResolverEndpointIpAddressOutcomeCallable DisassociateResolverEndpointIpAddressCallable(
      const DisassociateResolverEndpointIpAddressRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DisassociateResolverEndpointIpAddress, request);
  }
 
  template <typename DisassociateResolverEndpointIpAddressRequestT = Model::DisassociateResolverEndpointIpAddressRequest>
  void DisassociateResolverEndpointIpAddressAsync(const DisassociateResolverEndpointIpAddressRequestT& request,
                                                  const DisassociateResolverEndpointIpAddressResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DisassociateResolverEndpointIpAddress, request, handler, context);
  }
 
  virtual Model::DisassociateResolverQueryLogConfigOutcome DisassociateResolverQueryLogConfig(
      const Model::DisassociateResolverQueryLogConfigRequest& request) const;
 
  template <typename DisassociateResolverQueryLogConfigRequestT = Model::DisassociateResolverQueryLogConfigRequest>
  Model::DisassociateResolverQueryLogConfigOutcomeCallable DisassociateResolverQueryLogConfigCallable(
      const DisassociateResolverQueryLogConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DisassociateResolverQueryLogConfig, request);
  }
 
  template <typename DisassociateResolverQueryLogConfigRequestT = Model::DisassociateResolverQueryLogConfigRequest>
  void DisassociateResolverQueryLogConfigAsync(const DisassociateResolverQueryLogConfigRequestT& request,
                                               const DisassociateResolverQueryLogConfigResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DisassociateResolverQueryLogConfig, request, handler, context);
  }
 
  virtual Model::DisassociateResolverRuleOutcome DisassociateResolverRule(const Model::DisassociateResolverRuleRequest& request) const;
 
  template <typename DisassociateResolverRuleRequestT = Model::DisassociateResolverRuleRequest>
  Model::DisassociateResolverRuleOutcomeCallable DisassociateResolverRuleCallable(const DisassociateResolverRuleRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::DisassociateResolverRule, request);
  }
 
  template <typename DisassociateResolverRuleRequestT = Model::DisassociateResolverRuleRequest>
  void DisassociateResolverRuleAsync(const DisassociateResolverRuleRequestT& request,
                                     const DisassociateResolverRuleResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::DisassociateResolverRule, request, handler, context);
  }
 
  virtual Model::GetFirewallConfigOutcome GetFirewallConfig(const Model::GetFirewallConfigRequest& request) const;
 
  template <typename GetFirewallConfigRequestT = Model::GetFirewallConfigRequest>
  Model::GetFirewallConfigOutcomeCallable GetFirewallConfigCallable(const GetFirewallConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetFirewallConfig, request);
  }
 
  template <typename GetFirewallConfigRequestT = Model::GetFirewallConfigRequest>
  void GetFirewallConfigAsync(const GetFirewallConfigRequestT& request, const GetFirewallConfigResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetFirewallConfig, 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(&Route53ResolverClient::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(&Route53ResolverClient::GetFirewallDomainList, request, handler, context);
  }
 
  virtual Model::GetFirewallRuleGroupOutcome GetFirewallRuleGroup(const Model::GetFirewallRuleGroupRequest& request) const;
 
  template <typename GetFirewallRuleGroupRequestT = Model::GetFirewallRuleGroupRequest>
  Model::GetFirewallRuleGroupOutcomeCallable GetFirewallRuleGroupCallable(const GetFirewallRuleGroupRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetFirewallRuleGroup, request);
  }
 
  template <typename GetFirewallRuleGroupRequestT = Model::GetFirewallRuleGroupRequest>
  void GetFirewallRuleGroupAsync(const GetFirewallRuleGroupRequestT& request, const GetFirewallRuleGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetFirewallRuleGroup, request, handler, context);
  }
 
  virtual Model::GetFirewallRuleGroupAssociationOutcome GetFirewallRuleGroupAssociation(
      const Model::GetFirewallRuleGroupAssociationRequest& request) const;
 
  template <typename GetFirewallRuleGroupAssociationRequestT = Model::GetFirewallRuleGroupAssociationRequest>
  Model::GetFirewallRuleGroupAssociationOutcomeCallable GetFirewallRuleGroupAssociationCallable(
      const GetFirewallRuleGroupAssociationRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetFirewallRuleGroupAssociation, request);
  }
 
  template <typename GetFirewallRuleGroupAssociationRequestT = Model::GetFirewallRuleGroupAssociationRequest>
  void GetFirewallRuleGroupAssociationAsync(const GetFirewallRuleGroupAssociationRequestT& request,
                                            const GetFirewallRuleGroupAssociationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetFirewallRuleGroupAssociation, request, handler, context);
  }
 
  virtual Model::GetFirewallRuleGroupPolicyOutcome GetFirewallRuleGroupPolicy(
      const Model::GetFirewallRuleGroupPolicyRequest& request) const;
 
  template <typename GetFirewallRuleGroupPolicyRequestT = Model::GetFirewallRuleGroupPolicyRequest>
  Model::GetFirewallRuleGroupPolicyOutcomeCallable GetFirewallRuleGroupPolicyCallable(
      const GetFirewallRuleGroupPolicyRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetFirewallRuleGroupPolicy, request);
  }
 
  template <typename GetFirewallRuleGroupPolicyRequestT = Model::GetFirewallRuleGroupPolicyRequest>
  void GetFirewallRuleGroupPolicyAsync(const GetFirewallRuleGroupPolicyRequestT& request,
                                       const GetFirewallRuleGroupPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetFirewallRuleGroupPolicy, request, handler, context);
  }
 
  virtual Model::GetOutpostResolverOutcome GetOutpostResolver(const Model::GetOutpostResolverRequest& request) const;
 
  template <typename GetOutpostResolverRequestT = Model::GetOutpostResolverRequest>
  Model::GetOutpostResolverOutcomeCallable GetOutpostResolverCallable(const GetOutpostResolverRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetOutpostResolver, request);
  }
 
  template <typename GetOutpostResolverRequestT = Model::GetOutpostResolverRequest>
  void GetOutpostResolverAsync(const GetOutpostResolverRequestT& request, const GetOutpostResolverResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetOutpostResolver, request, handler, context);
  }
 
  virtual Model::GetResolverConfigOutcome GetResolverConfig(const Model::GetResolverConfigRequest& request) const;
 
  template <typename GetResolverConfigRequestT = Model::GetResolverConfigRequest>
  Model::GetResolverConfigOutcomeCallable GetResolverConfigCallable(const GetResolverConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverConfig, request);
  }
 
  template <typename GetResolverConfigRequestT = Model::GetResolverConfigRequest>
  void GetResolverConfigAsync(const GetResolverConfigRequestT& request, const GetResolverConfigResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverConfig, request, handler, context);
  }
 
  virtual Model::GetResolverDnssecConfigOutcome GetResolverDnssecConfig(const Model::GetResolverDnssecConfigRequest& request) const;
 
  template <typename GetResolverDnssecConfigRequestT = Model::GetResolverDnssecConfigRequest>
  Model::GetResolverDnssecConfigOutcomeCallable GetResolverDnssecConfigCallable(const GetResolverDnssecConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverDnssecConfig, request);
  }
 
  template <typename GetResolverDnssecConfigRequestT = Model::GetResolverDnssecConfigRequest>
  void GetResolverDnssecConfigAsync(const GetResolverDnssecConfigRequestT& request,
                                    const GetResolverDnssecConfigResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverDnssecConfig, request, handler, context);
  }
 
  virtual Model::GetResolverEndpointOutcome GetResolverEndpoint(const Model::GetResolverEndpointRequest& request) const;
 
  template <typename GetResolverEndpointRequestT = Model::GetResolverEndpointRequest>
  Model::GetResolverEndpointOutcomeCallable GetResolverEndpointCallable(const GetResolverEndpointRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverEndpoint, request);
  }
 
  template <typename GetResolverEndpointRequestT = Model::GetResolverEndpointRequest>
  void GetResolverEndpointAsync(const GetResolverEndpointRequestT& request, const GetResolverEndpointResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverEndpoint, request, handler, context);
  }
 
  virtual Model::GetResolverQueryLogConfigOutcome GetResolverQueryLogConfig(const Model::GetResolverQueryLogConfigRequest& request) const;
 
  template <typename GetResolverQueryLogConfigRequestT = Model::GetResolverQueryLogConfigRequest>
  Model::GetResolverQueryLogConfigOutcomeCallable GetResolverQueryLogConfigCallable(
      const GetResolverQueryLogConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverQueryLogConfig, request);
  }
 
  template <typename GetResolverQueryLogConfigRequestT = Model::GetResolverQueryLogConfigRequest>
  void GetResolverQueryLogConfigAsync(const GetResolverQueryLogConfigRequestT& request,
                                      const GetResolverQueryLogConfigResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverQueryLogConfig, request, handler, context);
  }
 
  virtual Model::GetResolverQueryLogConfigAssociationOutcome GetResolverQueryLogConfigAssociation(
      const Model::GetResolverQueryLogConfigAssociationRequest& request) const;
 
  template <typename GetResolverQueryLogConfigAssociationRequestT = Model::GetResolverQueryLogConfigAssociationRequest>
  Model::GetResolverQueryLogConfigAssociationOutcomeCallable GetResolverQueryLogConfigAssociationCallable(
      const GetResolverQueryLogConfigAssociationRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverQueryLogConfigAssociation, request);
  }
 
  template <typename GetResolverQueryLogConfigAssociationRequestT = Model::GetResolverQueryLogConfigAssociationRequest>
  void GetResolverQueryLogConfigAssociationAsync(const GetResolverQueryLogConfigAssociationRequestT& request,
                                                 const GetResolverQueryLogConfigAssociationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverQueryLogConfigAssociation, request, handler, context);
  }
 
  virtual Model::GetResolverQueryLogConfigPolicyOutcome GetResolverQueryLogConfigPolicy(
      const Model::GetResolverQueryLogConfigPolicyRequest& request) const;
 
  template <typename GetResolverQueryLogConfigPolicyRequestT = Model::GetResolverQueryLogConfigPolicyRequest>
  Model::GetResolverQueryLogConfigPolicyOutcomeCallable GetResolverQueryLogConfigPolicyCallable(
      const GetResolverQueryLogConfigPolicyRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverQueryLogConfigPolicy, request);
  }
 
  template <typename GetResolverQueryLogConfigPolicyRequestT = Model::GetResolverQueryLogConfigPolicyRequest>
  void GetResolverQueryLogConfigPolicyAsync(const GetResolverQueryLogConfigPolicyRequestT& request,
                                            const GetResolverQueryLogConfigPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverQueryLogConfigPolicy, request, handler, context);
  }
 
  virtual Model::GetResolverRuleOutcome GetResolverRule(const Model::GetResolverRuleRequest& request) const;
 
  template <typename GetResolverRuleRequestT = Model::GetResolverRuleRequest>
  Model::GetResolverRuleOutcomeCallable GetResolverRuleCallable(const GetResolverRuleRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverRule, request);
  }
 
  template <typename GetResolverRuleRequestT = Model::GetResolverRuleRequest>
  void GetResolverRuleAsync(const GetResolverRuleRequestT& request, const GetResolverRuleResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverRule, request, handler, context);
  }
 
  virtual Model::GetResolverRuleAssociationOutcome GetResolverRuleAssociation(
      const Model::GetResolverRuleAssociationRequest& request) const;
 
  template <typename GetResolverRuleAssociationRequestT = Model::GetResolverRuleAssociationRequest>
  Model::GetResolverRuleAssociationOutcomeCallable GetResolverRuleAssociationCallable(
      const GetResolverRuleAssociationRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverRuleAssociation, request);
  }
 
  template <typename GetResolverRuleAssociationRequestT = Model::GetResolverRuleAssociationRequest>
  void GetResolverRuleAssociationAsync(const GetResolverRuleAssociationRequestT& request,
                                       const GetResolverRuleAssociationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverRuleAssociation, request, handler, context);
  }
 
  virtual Model::GetResolverRulePolicyOutcome GetResolverRulePolicy(const Model::GetResolverRulePolicyRequest& request) const;
 
  template <typename GetResolverRulePolicyRequestT = Model::GetResolverRulePolicyRequest>
  Model::GetResolverRulePolicyOutcomeCallable GetResolverRulePolicyCallable(const GetResolverRulePolicyRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::GetResolverRulePolicy, request);
  }
 
  template <typename GetResolverRulePolicyRequestT = Model::GetResolverRulePolicyRequest>
  void GetResolverRulePolicyAsync(const GetResolverRulePolicyRequestT& request, const GetResolverRulePolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::GetResolverRulePolicy, 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(&Route53ResolverClient::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(&Route53ResolverClient::ImportFirewallDomains, request, handler, context);
  }
 
  virtual Model::ListFirewallConfigsOutcome ListFirewallConfigs(const Model::ListFirewallConfigsRequest& request = {}) const;
 
  template <typename ListFirewallConfigsRequestT = Model::ListFirewallConfigsRequest>
  Model::ListFirewallConfigsOutcomeCallable ListFirewallConfigsCallable(const ListFirewallConfigsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListFirewallConfigs, request);
  }
 
  template <typename ListFirewallConfigsRequestT = Model::ListFirewallConfigsRequest>
  void ListFirewallConfigsAsync(const ListFirewallConfigsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListFirewallConfigsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListFirewallConfigs, 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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::ListFirewallDomains, request, handler, context);
  }
 
  virtual Model::ListFirewallRuleGroupAssociationsOutcome ListFirewallRuleGroupAssociations(
      const Model::ListFirewallRuleGroupAssociationsRequest& request = {}) const;
 
  template <typename ListFirewallRuleGroupAssociationsRequestT = Model::ListFirewallRuleGroupAssociationsRequest>
  Model::ListFirewallRuleGroupAssociationsOutcomeCallable ListFirewallRuleGroupAssociationsCallable(
      const ListFirewallRuleGroupAssociationsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListFirewallRuleGroupAssociations, request);
  }
 
  template <typename ListFirewallRuleGroupAssociationsRequestT = Model::ListFirewallRuleGroupAssociationsRequest>
  void ListFirewallRuleGroupAssociationsAsync(const ListFirewallRuleGroupAssociationsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ListFirewallRuleGroupAssociationsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListFirewallRuleGroupAssociations, request, handler, context);
  }
 
  virtual Model::ListFirewallRuleGroupsOutcome ListFirewallRuleGroups(const Model::ListFirewallRuleGroupsRequest& request = {}) const;
 
  template <typename ListFirewallRuleGroupsRequestT = Model::ListFirewallRuleGroupsRequest>
  Model::ListFirewallRuleGroupsOutcomeCallable ListFirewallRuleGroupsCallable(const ListFirewallRuleGroupsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListFirewallRuleGroups, request);
  }
 
  template <typename ListFirewallRuleGroupsRequestT = Model::ListFirewallRuleGroupsRequest>
  void ListFirewallRuleGroupsAsync(const ListFirewallRuleGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListFirewallRuleGroupsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListFirewallRuleGroups, 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(&Route53ResolverClient::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(&Route53ResolverClient::ListFirewallRules, request, handler, context);
  }
 
  virtual Model::ListOutpostResolversOutcome ListOutpostResolvers(const Model::ListOutpostResolversRequest& request = {}) const;
 
  template <typename ListOutpostResolversRequestT = Model::ListOutpostResolversRequest>
  Model::ListOutpostResolversOutcomeCallable ListOutpostResolversCallable(const ListOutpostResolversRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListOutpostResolvers, request);
  }
 
  template <typename ListOutpostResolversRequestT = Model::ListOutpostResolversRequest>
  void ListOutpostResolversAsync(const ListOutpostResolversResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListOutpostResolversRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListOutpostResolvers, request, handler, context);
  }
 
  virtual Model::ListResolverConfigsOutcome ListResolverConfigs(const Model::ListResolverConfigsRequest& request = {}) const;
 
  template <typename ListResolverConfigsRequestT = Model::ListResolverConfigsRequest>
  Model::ListResolverConfigsOutcomeCallable ListResolverConfigsCallable(const ListResolverConfigsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverConfigs, request);
  }
 
  template <typename ListResolverConfigsRequestT = Model::ListResolverConfigsRequest>
  void ListResolverConfigsAsync(const ListResolverConfigsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListResolverConfigsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverConfigs, request, handler, context);
  }
 
  virtual Model::ListResolverDnssecConfigsOutcome ListResolverDnssecConfigs(
      const Model::ListResolverDnssecConfigsRequest& request = {}) const;
 
  template <typename ListResolverDnssecConfigsRequestT = Model::ListResolverDnssecConfigsRequest>
  Model::ListResolverDnssecConfigsOutcomeCallable ListResolverDnssecConfigsCallable(
      const ListResolverDnssecConfigsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverDnssecConfigs, request);
  }
 
  template <typename ListResolverDnssecConfigsRequestT = Model::ListResolverDnssecConfigsRequest>
  void ListResolverDnssecConfigsAsync(const ListResolverDnssecConfigsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListResolverDnssecConfigsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverDnssecConfigs, request, handler, context);
  }
 
  virtual Model::ListResolverEndpointIpAddressesOutcome ListResolverEndpointIpAddresses(
      const Model::ListResolverEndpointIpAddressesRequest& request) const;
 
  template <typename ListResolverEndpointIpAddressesRequestT = Model::ListResolverEndpointIpAddressesRequest>
  Model::ListResolverEndpointIpAddressesOutcomeCallable ListResolverEndpointIpAddressesCallable(
      const ListResolverEndpointIpAddressesRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverEndpointIpAddresses, request);
  }
 
  template <typename ListResolverEndpointIpAddressesRequestT = Model::ListResolverEndpointIpAddressesRequest>
  void ListResolverEndpointIpAddressesAsync(const ListResolverEndpointIpAddressesRequestT& request,
                                            const ListResolverEndpointIpAddressesResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverEndpointIpAddresses, request, handler, context);
  }
 
  virtual Model::ListResolverEndpointsOutcome ListResolverEndpoints(const Model::ListResolverEndpointsRequest& request = {}) const;
 
  template <typename ListResolverEndpointsRequestT = Model::ListResolverEndpointsRequest>
  Model::ListResolverEndpointsOutcomeCallable ListResolverEndpointsCallable(const ListResolverEndpointsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverEndpoints, request);
  }
 
  template <typename ListResolverEndpointsRequestT = Model::ListResolverEndpointsRequest>
  void ListResolverEndpointsAsync(const ListResolverEndpointsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListResolverEndpointsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverEndpoints, request, handler, context);
  }
 
  virtual Model::ListResolverQueryLogConfigAssociationsOutcome ListResolverQueryLogConfigAssociations(
      const Model::ListResolverQueryLogConfigAssociationsRequest& request = {}) const;
 
  template <typename ListResolverQueryLogConfigAssociationsRequestT = Model::ListResolverQueryLogConfigAssociationsRequest>
  Model::ListResolverQueryLogConfigAssociationsOutcomeCallable ListResolverQueryLogConfigAssociationsCallable(
      const ListResolverQueryLogConfigAssociationsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverQueryLogConfigAssociations, request);
  }
 
  template <typename ListResolverQueryLogConfigAssociationsRequestT = Model::ListResolverQueryLogConfigAssociationsRequest>
  void ListResolverQueryLogConfigAssociationsAsync(const ListResolverQueryLogConfigAssociationsResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const ListResolverQueryLogConfigAssociationsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverQueryLogConfigAssociations, request, handler, context);
  }
 
  virtual Model::ListResolverQueryLogConfigsOutcome ListResolverQueryLogConfigs(
      const Model::ListResolverQueryLogConfigsRequest& request = {}) const;
 
  template <typename ListResolverQueryLogConfigsRequestT = Model::ListResolverQueryLogConfigsRequest>
  Model::ListResolverQueryLogConfigsOutcomeCallable ListResolverQueryLogConfigsCallable(
      const ListResolverQueryLogConfigsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverQueryLogConfigs, request);
  }
 
  template <typename ListResolverQueryLogConfigsRequestT = Model::ListResolverQueryLogConfigsRequest>
  void ListResolverQueryLogConfigsAsync(const ListResolverQueryLogConfigsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListResolverQueryLogConfigsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverQueryLogConfigs, request, handler, context);
  }
 
  virtual Model::ListResolverRuleAssociationsOutcome ListResolverRuleAssociations(
      const Model::ListResolverRuleAssociationsRequest& request = {}) const;
 
  template <typename ListResolverRuleAssociationsRequestT = Model::ListResolverRuleAssociationsRequest>
  Model::ListResolverRuleAssociationsOutcomeCallable ListResolverRuleAssociationsCallable(
      const ListResolverRuleAssociationsRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverRuleAssociations, request);
  }
 
  template <typename ListResolverRuleAssociationsRequestT = Model::ListResolverRuleAssociationsRequest>
  void ListResolverRuleAssociationsAsync(const ListResolverRuleAssociationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListResolverRuleAssociationsRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverRuleAssociations, request, handler, context);
  }
 
  virtual Model::ListResolverRulesOutcome ListResolverRules(const Model::ListResolverRulesRequest& request = {}) const;
 
  template <typename ListResolverRulesRequestT = Model::ListResolverRulesRequest>
  Model::ListResolverRulesOutcomeCallable ListResolverRulesCallable(const ListResolverRulesRequestT& request = {}) const {
    return SubmitCallable(&Route53ResolverClient::ListResolverRules, request);
  }
 
  template <typename ListResolverRulesRequestT = Model::ListResolverRulesRequest>
  void ListResolverRulesAsync(const ListResolverRulesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListResolverRulesRequestT& request = {}) const {
    return SubmitAsync(&Route53ResolverClient::ListResolverRules, 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(&Route53ResolverClient::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(&Route53ResolverClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutFirewallRuleGroupPolicyOutcome PutFirewallRuleGroupPolicy(
      const Model::PutFirewallRuleGroupPolicyRequest& request) const;
 
  template <typename PutFirewallRuleGroupPolicyRequestT = Model::PutFirewallRuleGroupPolicyRequest>
  Model::PutFirewallRuleGroupPolicyOutcomeCallable PutFirewallRuleGroupPolicyCallable(
      const PutFirewallRuleGroupPolicyRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::PutFirewallRuleGroupPolicy, request);
  }
 
  template <typename PutFirewallRuleGroupPolicyRequestT = Model::PutFirewallRuleGroupPolicyRequest>
  void PutFirewallRuleGroupPolicyAsync(const PutFirewallRuleGroupPolicyRequestT& request,
                                       const PutFirewallRuleGroupPolicyResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::PutFirewallRuleGroupPolicy, request, handler, context);
  }
 
  virtual Model::PutResolverQueryLogConfigPolicyOutcome PutResolverQueryLogConfigPolicy(
      const Model::PutResolverQueryLogConfigPolicyRequest& request) const;
 
  template <typename PutResolverQueryLogConfigPolicyRequestT = Model::PutResolverQueryLogConfigPolicyRequest>
  Model::PutResolverQueryLogConfigPolicyOutcomeCallable PutResolverQueryLogConfigPolicyCallable(
      const PutResolverQueryLogConfigPolicyRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::PutResolverQueryLogConfigPolicy, request);
  }
 
  template <typename PutResolverQueryLogConfigPolicyRequestT = Model::PutResolverQueryLogConfigPolicyRequest>
  void PutResolverQueryLogConfigPolicyAsync(const PutResolverQueryLogConfigPolicyRequestT& request,
                                            const PutResolverQueryLogConfigPolicyResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::PutResolverQueryLogConfigPolicy, request, handler, context);
  }
 
  virtual Model::PutResolverRulePolicyOutcome PutResolverRulePolicy(const Model::PutResolverRulePolicyRequest& request) const;
 
  template <typename PutResolverRulePolicyRequestT = Model::PutResolverRulePolicyRequest>
  Model::PutResolverRulePolicyOutcomeCallable PutResolverRulePolicyCallable(const PutResolverRulePolicyRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::PutResolverRulePolicy, request);
  }
 
  template <typename PutResolverRulePolicyRequestT = Model::PutResolverRulePolicyRequest>
  void PutResolverRulePolicyAsync(const PutResolverRulePolicyRequestT& request, const PutResolverRulePolicyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::PutResolverRulePolicy, 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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateFirewallConfigOutcome UpdateFirewallConfig(const Model::UpdateFirewallConfigRequest& request) const;
 
  template <typename UpdateFirewallConfigRequestT = Model::UpdateFirewallConfigRequest>
  Model::UpdateFirewallConfigOutcomeCallable UpdateFirewallConfigCallable(const UpdateFirewallConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::UpdateFirewallConfig, request);
  }
 
  template <typename UpdateFirewallConfigRequestT = Model::UpdateFirewallConfigRequest>
  void UpdateFirewallConfigAsync(const UpdateFirewallConfigRequestT& request, const UpdateFirewallConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::UpdateFirewallConfig, 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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::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(&Route53ResolverClient::UpdateFirewallRule, request, handler, context);
  }
 
  virtual Model::UpdateFirewallRuleGroupAssociationOutcome UpdateFirewallRuleGroupAssociation(
      const Model::UpdateFirewallRuleGroupAssociationRequest& request) const;
 
  template <typename UpdateFirewallRuleGroupAssociationRequestT = Model::UpdateFirewallRuleGroupAssociationRequest>
  Model::UpdateFirewallRuleGroupAssociationOutcomeCallable UpdateFirewallRuleGroupAssociationCallable(
      const UpdateFirewallRuleGroupAssociationRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::UpdateFirewallRuleGroupAssociation, request);
  }
 
  template <typename UpdateFirewallRuleGroupAssociationRequestT = Model::UpdateFirewallRuleGroupAssociationRequest>
  void UpdateFirewallRuleGroupAssociationAsync(const UpdateFirewallRuleGroupAssociationRequestT& request,
                                               const UpdateFirewallRuleGroupAssociationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::UpdateFirewallRuleGroupAssociation, request, handler, context);
  }
 
  virtual Model::UpdateOutpostResolverOutcome UpdateOutpostResolver(const Model::UpdateOutpostResolverRequest& request) const;
 
  template <typename UpdateOutpostResolverRequestT = Model::UpdateOutpostResolverRequest>
  Model::UpdateOutpostResolverOutcomeCallable UpdateOutpostResolverCallable(const UpdateOutpostResolverRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::UpdateOutpostResolver, request);
  }
 
  template <typename UpdateOutpostResolverRequestT = Model::UpdateOutpostResolverRequest>
  void UpdateOutpostResolverAsync(const UpdateOutpostResolverRequestT& request, const UpdateOutpostResolverResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::UpdateOutpostResolver, request, handler, context);
  }
 
  virtual Model::UpdateResolverConfigOutcome UpdateResolverConfig(const Model::UpdateResolverConfigRequest& request) const;
 
  template <typename UpdateResolverConfigRequestT = Model::UpdateResolverConfigRequest>
  Model::UpdateResolverConfigOutcomeCallable UpdateResolverConfigCallable(const UpdateResolverConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::UpdateResolverConfig, request);
  }
 
  template <typename UpdateResolverConfigRequestT = Model::UpdateResolverConfigRequest>
  void UpdateResolverConfigAsync(const UpdateResolverConfigRequestT& request, const UpdateResolverConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::UpdateResolverConfig, request, handler, context);
  }
 
  virtual Model::UpdateResolverDnssecConfigOutcome UpdateResolverDnssecConfig(
      const Model::UpdateResolverDnssecConfigRequest& request) const;
 
  template <typename UpdateResolverDnssecConfigRequestT = Model::UpdateResolverDnssecConfigRequest>
  Model::UpdateResolverDnssecConfigOutcomeCallable UpdateResolverDnssecConfigCallable(
      const UpdateResolverDnssecConfigRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::UpdateResolverDnssecConfig, request);
  }
 
  template <typename UpdateResolverDnssecConfigRequestT = Model::UpdateResolverDnssecConfigRequest>
  void UpdateResolverDnssecConfigAsync(const UpdateResolverDnssecConfigRequestT& request,
                                       const UpdateResolverDnssecConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::UpdateResolverDnssecConfig, request, handler, context);
  }
 
  virtual Model::UpdateResolverEndpointOutcome UpdateResolverEndpoint(const Model::UpdateResolverEndpointRequest& request) const;
 
  template <typename UpdateResolverEndpointRequestT = Model::UpdateResolverEndpointRequest>
  Model::UpdateResolverEndpointOutcomeCallable UpdateResolverEndpointCallable(const UpdateResolverEndpointRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::UpdateResolverEndpoint, request);
  }
 
  template <typename UpdateResolverEndpointRequestT = Model::UpdateResolverEndpointRequest>
  void UpdateResolverEndpointAsync(const UpdateResolverEndpointRequestT& request,
                                   const UpdateResolverEndpointResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::UpdateResolverEndpoint, request, handler, context);
  }
 
  virtual Model::UpdateResolverRuleOutcome UpdateResolverRule(const Model::UpdateResolverRuleRequest& request) const;
 
  template <typename UpdateResolverRuleRequestT = Model::UpdateResolverRuleRequest>
  Model::UpdateResolverRuleOutcomeCallable UpdateResolverRuleCallable(const UpdateResolverRuleRequestT& request) const {
    return SubmitCallable(&Route53ResolverClient::UpdateResolverRule, request);
  }
 
  template <typename UpdateResolverRuleRequestT = Model::UpdateResolverRuleRequest>
  void UpdateResolverRuleAsync(const UpdateResolverRuleRequestT& request, const UpdateResolverRuleResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&Route53ResolverClient::UpdateResolverRule, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<Route53ResolverEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53ResolverClient>;
  void init(const Route53ResolverClientConfiguration& clientConfiguration);
 
  Route53ResolverClientConfiguration m_clientConfiguration;
  std::shared_ptr<Route53ResolverEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Route53Resolver
}  // namespace Aws