Route53ResolverClient.h

 
#pragma once
#include <aws/route53resolver/Route53Resolver_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/route53resolver/Route53ResolverServiceClientModel.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