WAFClient.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/waf/WAFPaginationBase.h>
#include <aws/waf/WAFServiceClientModel.h>
#include <aws/waf/WAFWaiter.h>
#include <aws/waf/WAF_EXPORTS.h>
 
namespace Aws {
namespace WAF {
class AWS_WAF_API WAFClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<WAFClient>,
                              public WAFPaginationBase<WAFClient>,
                              public WAFWaiter<WAFClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef WAFClientConfiguration ClientConfigurationType;
  typedef WAFEndpointProvider EndpointProviderType;
 
  WAFClient(const Aws::WAF::WAFClientConfiguration& clientConfiguration = Aws::WAF::WAFClientConfiguration(),
            std::shared_ptr<WAFEndpointProviderBase> endpointProvider = nullptr);
 
  WAFClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<WAFEndpointProviderBase> endpointProvider = nullptr,
            const Aws::WAF::WAFClientConfiguration& clientConfiguration = Aws::WAF::WAFClientConfiguration());
 
  WAFClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<WAFEndpointProviderBase> endpointProvider = nullptr,
            const Aws::WAF::WAFClientConfiguration& clientConfiguration = Aws::WAF::WAFClientConfiguration());
 
  /* Legacy constructors due deprecation */
  WAFClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  WAFClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  WAFClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~WAFClient();
 
  virtual Model::CreateByteMatchSetOutcome CreateByteMatchSet(const Model::CreateByteMatchSetRequest& request) const;
 
  template <typename CreateByteMatchSetRequestT = Model::CreateByteMatchSetRequest>
  Model::CreateByteMatchSetOutcomeCallable CreateByteMatchSetCallable(const CreateByteMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateByteMatchSet, request);
  }
 
  template <typename CreateByteMatchSetRequestT = Model::CreateByteMatchSetRequest>
  void CreateByteMatchSetAsync(const CreateByteMatchSetRequestT& request, const CreateByteMatchSetResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateByteMatchSet, request, handler, context);
  }
 
  virtual Model::CreateGeoMatchSetOutcome CreateGeoMatchSet(const Model::CreateGeoMatchSetRequest& request) const;
 
  template <typename CreateGeoMatchSetRequestT = Model::CreateGeoMatchSetRequest>
  Model::CreateGeoMatchSetOutcomeCallable CreateGeoMatchSetCallable(const CreateGeoMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateGeoMatchSet, request);
  }
 
  template <typename CreateGeoMatchSetRequestT = Model::CreateGeoMatchSetRequest>
  void CreateGeoMatchSetAsync(const CreateGeoMatchSetRequestT& request, const CreateGeoMatchSetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateGeoMatchSet, request, handler, context);
  }
 
  virtual Model::CreateIPSetOutcome CreateIPSet(const Model::CreateIPSetRequest& request) const;
 
  template <typename CreateIPSetRequestT = Model::CreateIPSetRequest>
  Model::CreateIPSetOutcomeCallable CreateIPSetCallable(const CreateIPSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateIPSet, request);
  }
 
  template <typename CreateIPSetRequestT = Model::CreateIPSetRequest>
  void CreateIPSetAsync(const CreateIPSetRequestT& request, const CreateIPSetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateIPSet, request, handler, context);
  }
 
  virtual Model::CreateRateBasedRuleOutcome CreateRateBasedRule(const Model::CreateRateBasedRuleRequest& request) const;
 
  template <typename CreateRateBasedRuleRequestT = Model::CreateRateBasedRuleRequest>
  Model::CreateRateBasedRuleOutcomeCallable CreateRateBasedRuleCallable(const CreateRateBasedRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateRateBasedRule, request);
  }
 
  template <typename CreateRateBasedRuleRequestT = Model::CreateRateBasedRuleRequest>
  void CreateRateBasedRuleAsync(const CreateRateBasedRuleRequestT& request, const CreateRateBasedRuleResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateRateBasedRule, request, handler, context);
  }
 
  virtual Model::CreateRegexMatchSetOutcome CreateRegexMatchSet(const Model::CreateRegexMatchSetRequest& request) const;
 
  template <typename CreateRegexMatchSetRequestT = Model::CreateRegexMatchSetRequest>
  Model::CreateRegexMatchSetOutcomeCallable CreateRegexMatchSetCallable(const CreateRegexMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateRegexMatchSet, request);
  }
 
  template <typename CreateRegexMatchSetRequestT = Model::CreateRegexMatchSetRequest>
  void CreateRegexMatchSetAsync(const CreateRegexMatchSetRequestT& request, const CreateRegexMatchSetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateRegexMatchSet, request, handler, context);
  }
 
  virtual Model::CreateRegexPatternSetOutcome CreateRegexPatternSet(const Model::CreateRegexPatternSetRequest& request) const;
 
  template <typename CreateRegexPatternSetRequestT = Model::CreateRegexPatternSetRequest>
  Model::CreateRegexPatternSetOutcomeCallable CreateRegexPatternSetCallable(const CreateRegexPatternSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateRegexPatternSet, request);
  }
 
  template <typename CreateRegexPatternSetRequestT = Model::CreateRegexPatternSetRequest>
  void CreateRegexPatternSetAsync(const CreateRegexPatternSetRequestT& request, const CreateRegexPatternSetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateRegexPatternSet, request, handler, context);
  }
 
  virtual Model::CreateRuleOutcome CreateRule(const Model::CreateRuleRequest& request) const;
 
  template <typename CreateRuleRequestT = Model::CreateRuleRequest>
  Model::CreateRuleOutcomeCallable CreateRuleCallable(const CreateRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateRule, request);
  }
 
  template <typename CreateRuleRequestT = Model::CreateRuleRequest>
  void CreateRuleAsync(const CreateRuleRequestT& request, const CreateRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateRule, request, handler, context);
  }
 
  virtual Model::CreateRuleGroupOutcome CreateRuleGroup(const Model::CreateRuleGroupRequest& request) const;
 
  template <typename CreateRuleGroupRequestT = Model::CreateRuleGroupRequest>
  Model::CreateRuleGroupOutcomeCallable CreateRuleGroupCallable(const CreateRuleGroupRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateRuleGroup, request);
  }
 
  template <typename CreateRuleGroupRequestT = Model::CreateRuleGroupRequest>
  void CreateRuleGroupAsync(const CreateRuleGroupRequestT& request, const CreateRuleGroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateRuleGroup, request, handler, context);
  }
 
  virtual Model::CreateSizeConstraintSetOutcome CreateSizeConstraintSet(const Model::CreateSizeConstraintSetRequest& request) const;
 
  template <typename CreateSizeConstraintSetRequestT = Model::CreateSizeConstraintSetRequest>
  Model::CreateSizeConstraintSetOutcomeCallable CreateSizeConstraintSetCallable(const CreateSizeConstraintSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateSizeConstraintSet, request);
  }
 
  template <typename CreateSizeConstraintSetRequestT = Model::CreateSizeConstraintSetRequest>
  void CreateSizeConstraintSetAsync(const CreateSizeConstraintSetRequestT& request,
                                    const CreateSizeConstraintSetResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateSizeConstraintSet, request, handler, context);
  }
 
  virtual Model::CreateSqlInjectionMatchSetOutcome CreateSqlInjectionMatchSet(
      const Model::CreateSqlInjectionMatchSetRequest& request) const;
 
  template <typename CreateSqlInjectionMatchSetRequestT = Model::CreateSqlInjectionMatchSetRequest>
  Model::CreateSqlInjectionMatchSetOutcomeCallable CreateSqlInjectionMatchSetCallable(
      const CreateSqlInjectionMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateSqlInjectionMatchSet, request);
  }
 
  template <typename CreateSqlInjectionMatchSetRequestT = Model::CreateSqlInjectionMatchSetRequest>
  void CreateSqlInjectionMatchSetAsync(const CreateSqlInjectionMatchSetRequestT& request,
                                       const CreateSqlInjectionMatchSetResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateSqlInjectionMatchSet, request, handler, context);
  }
 
  virtual Model::CreateWebACLOutcome CreateWebACL(const Model::CreateWebACLRequest& request) const;
 
  template <typename CreateWebACLRequestT = Model::CreateWebACLRequest>
  Model::CreateWebACLOutcomeCallable CreateWebACLCallable(const CreateWebACLRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateWebACL, request);
  }
 
  template <typename CreateWebACLRequestT = Model::CreateWebACLRequest>
  void CreateWebACLAsync(const CreateWebACLRequestT& request, const CreateWebACLResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateWebACL, request, handler, context);
  }
 
  virtual Model::CreateWebACLMigrationStackOutcome CreateWebACLMigrationStack(
      const Model::CreateWebACLMigrationStackRequest& request) const;
 
  template <typename CreateWebACLMigrationStackRequestT = Model::CreateWebACLMigrationStackRequest>
  Model::CreateWebACLMigrationStackOutcomeCallable CreateWebACLMigrationStackCallable(
      const CreateWebACLMigrationStackRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateWebACLMigrationStack, request);
  }
 
  template <typename CreateWebACLMigrationStackRequestT = Model::CreateWebACLMigrationStackRequest>
  void CreateWebACLMigrationStackAsync(const CreateWebACLMigrationStackRequestT& request,
                                       const CreateWebACLMigrationStackResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateWebACLMigrationStack, request, handler, context);
  }
 
  virtual Model::CreateXssMatchSetOutcome CreateXssMatchSet(const Model::CreateXssMatchSetRequest& request) const;
 
  template <typename CreateXssMatchSetRequestT = Model::CreateXssMatchSetRequest>
  Model::CreateXssMatchSetOutcomeCallable CreateXssMatchSetCallable(const CreateXssMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::CreateXssMatchSet, request);
  }
 
  template <typename CreateXssMatchSetRequestT = Model::CreateXssMatchSetRequest>
  void CreateXssMatchSetAsync(const CreateXssMatchSetRequestT& request, const CreateXssMatchSetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::CreateXssMatchSet, request, handler, context);
  }
 
  virtual Model::DeleteByteMatchSetOutcome DeleteByteMatchSet(const Model::DeleteByteMatchSetRequest& request) const;
 
  template <typename DeleteByteMatchSetRequestT = Model::DeleteByteMatchSetRequest>
  Model::DeleteByteMatchSetOutcomeCallable DeleteByteMatchSetCallable(const DeleteByteMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteByteMatchSet, request);
  }
 
  template <typename DeleteByteMatchSetRequestT = Model::DeleteByteMatchSetRequest>
  void DeleteByteMatchSetAsync(const DeleteByteMatchSetRequestT& request, const DeleteByteMatchSetResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteByteMatchSet, request, handler, context);
  }
 
  virtual Model::DeleteGeoMatchSetOutcome DeleteGeoMatchSet(const Model::DeleteGeoMatchSetRequest& request) const;
 
  template <typename DeleteGeoMatchSetRequestT = Model::DeleteGeoMatchSetRequest>
  Model::DeleteGeoMatchSetOutcomeCallable DeleteGeoMatchSetCallable(const DeleteGeoMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteGeoMatchSet, request);
  }
 
  template <typename DeleteGeoMatchSetRequestT = Model::DeleteGeoMatchSetRequest>
  void DeleteGeoMatchSetAsync(const DeleteGeoMatchSetRequestT& request, const DeleteGeoMatchSetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteGeoMatchSet, request, handler, context);
  }
 
  virtual Model::DeleteIPSetOutcome DeleteIPSet(const Model::DeleteIPSetRequest& request) const;
 
  template <typename DeleteIPSetRequestT = Model::DeleteIPSetRequest>
  Model::DeleteIPSetOutcomeCallable DeleteIPSetCallable(const DeleteIPSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteIPSet, request);
  }
 
  template <typename DeleteIPSetRequestT = Model::DeleteIPSetRequest>
  void DeleteIPSetAsync(const DeleteIPSetRequestT& request, const DeleteIPSetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteIPSet, request, handler, context);
  }
 
  virtual Model::DeleteLoggingConfigurationOutcome DeleteLoggingConfiguration(
      const Model::DeleteLoggingConfigurationRequest& request) const;
 
  template <typename DeleteLoggingConfigurationRequestT = Model::DeleteLoggingConfigurationRequest>
  Model::DeleteLoggingConfigurationOutcomeCallable DeleteLoggingConfigurationCallable(
      const DeleteLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteLoggingConfiguration, request);
  }
 
  template <typename DeleteLoggingConfigurationRequestT = Model::DeleteLoggingConfigurationRequest>
  void DeleteLoggingConfigurationAsync(const DeleteLoggingConfigurationRequestT& request,
                                       const DeleteLoggingConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::DeletePermissionPolicyOutcome DeletePermissionPolicy(const Model::DeletePermissionPolicyRequest& request) const;
 
  template <typename DeletePermissionPolicyRequestT = Model::DeletePermissionPolicyRequest>
  Model::DeletePermissionPolicyOutcomeCallable DeletePermissionPolicyCallable(const DeletePermissionPolicyRequestT& request) const {
    return SubmitCallable(&WAFClient::DeletePermissionPolicy, request);
  }
 
  template <typename DeletePermissionPolicyRequestT = Model::DeletePermissionPolicyRequest>
  void DeletePermissionPolicyAsync(const DeletePermissionPolicyRequestT& request,
                                   const DeletePermissionPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeletePermissionPolicy, request, handler, context);
  }
 
  virtual Model::DeleteRateBasedRuleOutcome DeleteRateBasedRule(const Model::DeleteRateBasedRuleRequest& request) const;
 
  template <typename DeleteRateBasedRuleRequestT = Model::DeleteRateBasedRuleRequest>
  Model::DeleteRateBasedRuleOutcomeCallable DeleteRateBasedRuleCallable(const DeleteRateBasedRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteRateBasedRule, request);
  }
 
  template <typename DeleteRateBasedRuleRequestT = Model::DeleteRateBasedRuleRequest>
  void DeleteRateBasedRuleAsync(const DeleteRateBasedRuleRequestT& request, const DeleteRateBasedRuleResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteRateBasedRule, request, handler, context);
  }
 
  virtual Model::DeleteRegexMatchSetOutcome DeleteRegexMatchSet(const Model::DeleteRegexMatchSetRequest& request) const;
 
  template <typename DeleteRegexMatchSetRequestT = Model::DeleteRegexMatchSetRequest>
  Model::DeleteRegexMatchSetOutcomeCallable DeleteRegexMatchSetCallable(const DeleteRegexMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteRegexMatchSet, request);
  }
 
  template <typename DeleteRegexMatchSetRequestT = Model::DeleteRegexMatchSetRequest>
  void DeleteRegexMatchSetAsync(const DeleteRegexMatchSetRequestT& request, const DeleteRegexMatchSetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteRegexMatchSet, request, handler, context);
  }
 
  virtual Model::DeleteRegexPatternSetOutcome DeleteRegexPatternSet(const Model::DeleteRegexPatternSetRequest& request) const;
 
  template <typename DeleteRegexPatternSetRequestT = Model::DeleteRegexPatternSetRequest>
  Model::DeleteRegexPatternSetOutcomeCallable DeleteRegexPatternSetCallable(const DeleteRegexPatternSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteRegexPatternSet, request);
  }
 
  template <typename DeleteRegexPatternSetRequestT = Model::DeleteRegexPatternSetRequest>
  void DeleteRegexPatternSetAsync(const DeleteRegexPatternSetRequestT& request, const DeleteRegexPatternSetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteRegexPatternSet, request, handler, context);
  }
 
  virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const;
 
  template <typename DeleteRuleRequestT = Model::DeleteRuleRequest>
  Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteRule, request);
  }
 
  template <typename DeleteRuleRequestT = Model::DeleteRuleRequest>
  void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteRule, request, handler, context);
  }
 
  virtual Model::DeleteRuleGroupOutcome DeleteRuleGroup(const Model::DeleteRuleGroupRequest& request) const;
 
  template <typename DeleteRuleGroupRequestT = Model::DeleteRuleGroupRequest>
  Model::DeleteRuleGroupOutcomeCallable DeleteRuleGroupCallable(const DeleteRuleGroupRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteRuleGroup, request);
  }
 
  template <typename DeleteRuleGroupRequestT = Model::DeleteRuleGroupRequest>
  void DeleteRuleGroupAsync(const DeleteRuleGroupRequestT& request, const DeleteRuleGroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteRuleGroup, request, handler, context);
  }
 
  virtual Model::DeleteSizeConstraintSetOutcome DeleteSizeConstraintSet(const Model::DeleteSizeConstraintSetRequest& request) const;
 
  template <typename DeleteSizeConstraintSetRequestT = Model::DeleteSizeConstraintSetRequest>
  Model::DeleteSizeConstraintSetOutcomeCallable DeleteSizeConstraintSetCallable(const DeleteSizeConstraintSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteSizeConstraintSet, request);
  }
 
  template <typename DeleteSizeConstraintSetRequestT = Model::DeleteSizeConstraintSetRequest>
  void DeleteSizeConstraintSetAsync(const DeleteSizeConstraintSetRequestT& request,
                                    const DeleteSizeConstraintSetResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteSizeConstraintSet, request, handler, context);
  }
 
  virtual Model::DeleteSqlInjectionMatchSetOutcome DeleteSqlInjectionMatchSet(
      const Model::DeleteSqlInjectionMatchSetRequest& request) const;
 
  template <typename DeleteSqlInjectionMatchSetRequestT = Model::DeleteSqlInjectionMatchSetRequest>
  Model::DeleteSqlInjectionMatchSetOutcomeCallable DeleteSqlInjectionMatchSetCallable(
      const DeleteSqlInjectionMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteSqlInjectionMatchSet, request);
  }
 
  template <typename DeleteSqlInjectionMatchSetRequestT = Model::DeleteSqlInjectionMatchSetRequest>
  void DeleteSqlInjectionMatchSetAsync(const DeleteSqlInjectionMatchSetRequestT& request,
                                       const DeleteSqlInjectionMatchSetResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteSqlInjectionMatchSet, request, handler, context);
  }
 
  virtual Model::DeleteWebACLOutcome DeleteWebACL(const Model::DeleteWebACLRequest& request) const;
 
  template <typename DeleteWebACLRequestT = Model::DeleteWebACLRequest>
  Model::DeleteWebACLOutcomeCallable DeleteWebACLCallable(const DeleteWebACLRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteWebACL, request);
  }
 
  template <typename DeleteWebACLRequestT = Model::DeleteWebACLRequest>
  void DeleteWebACLAsync(const DeleteWebACLRequestT& request, const DeleteWebACLResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteWebACL, request, handler, context);
  }
 
  virtual Model::DeleteXssMatchSetOutcome DeleteXssMatchSet(const Model::DeleteXssMatchSetRequest& request) const;
 
  template <typename DeleteXssMatchSetRequestT = Model::DeleteXssMatchSetRequest>
  Model::DeleteXssMatchSetOutcomeCallable DeleteXssMatchSetCallable(const DeleteXssMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::DeleteXssMatchSet, request);
  }
 
  template <typename DeleteXssMatchSetRequestT = Model::DeleteXssMatchSetRequest>
  void DeleteXssMatchSetAsync(const DeleteXssMatchSetRequestT& request, const DeleteXssMatchSetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::DeleteXssMatchSet, request, handler, context);
  }
 
  virtual Model::GetByteMatchSetOutcome GetByteMatchSet(const Model::GetByteMatchSetRequest& request) const;
 
  template <typename GetByteMatchSetRequestT = Model::GetByteMatchSetRequest>
  Model::GetByteMatchSetOutcomeCallable GetByteMatchSetCallable(const GetByteMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetByteMatchSet, request);
  }
 
  template <typename GetByteMatchSetRequestT = Model::GetByteMatchSetRequest>
  void GetByteMatchSetAsync(const GetByteMatchSetRequestT& request, const GetByteMatchSetResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetByteMatchSet, request, handler, context);
  }
 
  virtual Model::GetChangeTokenOutcome GetChangeToken(const Model::GetChangeTokenRequest& request = {}) const;
 
  template <typename GetChangeTokenRequestT = Model::GetChangeTokenRequest>
  Model::GetChangeTokenOutcomeCallable GetChangeTokenCallable(const GetChangeTokenRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::GetChangeToken, request);
  }
 
  template <typename GetChangeTokenRequestT = Model::GetChangeTokenRequest>
  void GetChangeTokenAsync(const GetChangeTokenResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GetChangeTokenRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::GetChangeToken, request, handler, context);
  }
 
  virtual Model::GetChangeTokenStatusOutcome GetChangeTokenStatus(const Model::GetChangeTokenStatusRequest& request) const;
 
  template <typename GetChangeTokenStatusRequestT = Model::GetChangeTokenStatusRequest>
  Model::GetChangeTokenStatusOutcomeCallable GetChangeTokenStatusCallable(const GetChangeTokenStatusRequestT& request) const {
    return SubmitCallable(&WAFClient::GetChangeTokenStatus, request);
  }
 
  template <typename GetChangeTokenStatusRequestT = Model::GetChangeTokenStatusRequest>
  void GetChangeTokenStatusAsync(const GetChangeTokenStatusRequestT& request, const GetChangeTokenStatusResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetChangeTokenStatus, request, handler, context);
  }
 
  virtual Model::GetGeoMatchSetOutcome GetGeoMatchSet(const Model::GetGeoMatchSetRequest& request) const;
 
  template <typename GetGeoMatchSetRequestT = Model::GetGeoMatchSetRequest>
  Model::GetGeoMatchSetOutcomeCallable GetGeoMatchSetCallable(const GetGeoMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetGeoMatchSet, request);
  }
 
  template <typename GetGeoMatchSetRequestT = Model::GetGeoMatchSetRequest>
  void GetGeoMatchSetAsync(const GetGeoMatchSetRequestT& request, const GetGeoMatchSetResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetGeoMatchSet, request, handler, context);
  }
 
  virtual Model::GetIPSetOutcome GetIPSet(const Model::GetIPSetRequest& request) const;
 
  template <typename GetIPSetRequestT = Model::GetIPSetRequest>
  Model::GetIPSetOutcomeCallable GetIPSetCallable(const GetIPSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetIPSet, request);
  }
 
  template <typename GetIPSetRequestT = Model::GetIPSetRequest>
  void GetIPSetAsync(const GetIPSetRequestT& request, const GetIPSetResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetIPSet, request, handler, context);
  }
 
  virtual Model::GetLoggingConfigurationOutcome GetLoggingConfiguration(const Model::GetLoggingConfigurationRequest& request) const;
 
  template <typename GetLoggingConfigurationRequestT = Model::GetLoggingConfigurationRequest>
  Model::GetLoggingConfigurationOutcomeCallable GetLoggingConfigurationCallable(const GetLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&WAFClient::GetLoggingConfiguration, request);
  }
 
  template <typename GetLoggingConfigurationRequestT = Model::GetLoggingConfigurationRequest>
  void GetLoggingConfigurationAsync(const GetLoggingConfigurationRequestT& request,
                                    const GetLoggingConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::GetPermissionPolicyOutcome GetPermissionPolicy(const Model::GetPermissionPolicyRequest& request) const;
 
  template <typename GetPermissionPolicyRequestT = Model::GetPermissionPolicyRequest>
  Model::GetPermissionPolicyOutcomeCallable GetPermissionPolicyCallable(const GetPermissionPolicyRequestT& request) const {
    return SubmitCallable(&WAFClient::GetPermissionPolicy, request);
  }
 
  template <typename GetPermissionPolicyRequestT = Model::GetPermissionPolicyRequest>
  void GetPermissionPolicyAsync(const GetPermissionPolicyRequestT& request, const GetPermissionPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetPermissionPolicy, request, handler, context);
  }
 
  virtual Model::GetRateBasedRuleOutcome GetRateBasedRule(const Model::GetRateBasedRuleRequest& request) const;
 
  template <typename GetRateBasedRuleRequestT = Model::GetRateBasedRuleRequest>
  Model::GetRateBasedRuleOutcomeCallable GetRateBasedRuleCallable(const GetRateBasedRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::GetRateBasedRule, request);
  }
 
  template <typename GetRateBasedRuleRequestT = Model::GetRateBasedRuleRequest>
  void GetRateBasedRuleAsync(const GetRateBasedRuleRequestT& request, const GetRateBasedRuleResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetRateBasedRule, request, handler, context);
  }
 
  virtual Model::GetRateBasedRuleManagedKeysOutcome GetRateBasedRuleManagedKeys(
      const Model::GetRateBasedRuleManagedKeysRequest& request) const;
 
  template <typename GetRateBasedRuleManagedKeysRequestT = Model::GetRateBasedRuleManagedKeysRequest>
  Model::GetRateBasedRuleManagedKeysOutcomeCallable GetRateBasedRuleManagedKeysCallable(
      const GetRateBasedRuleManagedKeysRequestT& request) const {
    return SubmitCallable(&WAFClient::GetRateBasedRuleManagedKeys, request);
  }
 
  template <typename GetRateBasedRuleManagedKeysRequestT = Model::GetRateBasedRuleManagedKeysRequest>
  void GetRateBasedRuleManagedKeysAsync(const GetRateBasedRuleManagedKeysRequestT& request,
                                        const GetRateBasedRuleManagedKeysResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetRateBasedRuleManagedKeys, request, handler, context);
  }
 
  virtual Model::GetRegexMatchSetOutcome GetRegexMatchSet(const Model::GetRegexMatchSetRequest& request) const;
 
  template <typename GetRegexMatchSetRequestT = Model::GetRegexMatchSetRequest>
  Model::GetRegexMatchSetOutcomeCallable GetRegexMatchSetCallable(const GetRegexMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetRegexMatchSet, request);
  }
 
  template <typename GetRegexMatchSetRequestT = Model::GetRegexMatchSetRequest>
  void GetRegexMatchSetAsync(const GetRegexMatchSetRequestT& request, const GetRegexMatchSetResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetRegexMatchSet, request, handler, context);
  }
 
  virtual Model::GetRegexPatternSetOutcome GetRegexPatternSet(const Model::GetRegexPatternSetRequest& request) const;
 
  template <typename GetRegexPatternSetRequestT = Model::GetRegexPatternSetRequest>
  Model::GetRegexPatternSetOutcomeCallable GetRegexPatternSetCallable(const GetRegexPatternSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetRegexPatternSet, request);
  }
 
  template <typename GetRegexPatternSetRequestT = Model::GetRegexPatternSetRequest>
  void GetRegexPatternSetAsync(const GetRegexPatternSetRequestT& request, const GetRegexPatternSetResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetRegexPatternSet, request, handler, context);
  }
 
  virtual Model::GetRuleOutcome GetRule(const Model::GetRuleRequest& request) const;
 
  template <typename GetRuleRequestT = Model::GetRuleRequest>
  Model::GetRuleOutcomeCallable GetRuleCallable(const GetRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::GetRule, request);
  }
 
  template <typename GetRuleRequestT = Model::GetRuleRequest>
  void GetRuleAsync(const GetRuleRequestT& request, const GetRuleResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetRule, request, handler, context);
  }
 
  virtual Model::GetRuleGroupOutcome GetRuleGroup(const Model::GetRuleGroupRequest& request) const;
 
  template <typename GetRuleGroupRequestT = Model::GetRuleGroupRequest>
  Model::GetRuleGroupOutcomeCallable GetRuleGroupCallable(const GetRuleGroupRequestT& request) const {
    return SubmitCallable(&WAFClient::GetRuleGroup, request);
  }
 
  template <typename GetRuleGroupRequestT = Model::GetRuleGroupRequest>
  void GetRuleGroupAsync(const GetRuleGroupRequestT& request, const GetRuleGroupResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetRuleGroup, request, handler, context);
  }
 
  virtual Model::GetSampledRequestsOutcome GetSampledRequests(const Model::GetSampledRequestsRequest& request) const;
 
  template <typename GetSampledRequestsRequestT = Model::GetSampledRequestsRequest>
  Model::GetSampledRequestsOutcomeCallable GetSampledRequestsCallable(const GetSampledRequestsRequestT& request) const {
    return SubmitCallable(&WAFClient::GetSampledRequests, request);
  }
 
  template <typename GetSampledRequestsRequestT = Model::GetSampledRequestsRequest>
  void GetSampledRequestsAsync(const GetSampledRequestsRequestT& request, const GetSampledRequestsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetSampledRequests, request, handler, context);
  }
 
  virtual Model::GetSizeConstraintSetOutcome GetSizeConstraintSet(const Model::GetSizeConstraintSetRequest& request) const;
 
  template <typename GetSizeConstraintSetRequestT = Model::GetSizeConstraintSetRequest>
  Model::GetSizeConstraintSetOutcomeCallable GetSizeConstraintSetCallable(const GetSizeConstraintSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetSizeConstraintSet, request);
  }
 
  template <typename GetSizeConstraintSetRequestT = Model::GetSizeConstraintSetRequest>
  void GetSizeConstraintSetAsync(const GetSizeConstraintSetRequestT& request, const GetSizeConstraintSetResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetSizeConstraintSet, request, handler, context);
  }
 
  virtual Model::GetSqlInjectionMatchSetOutcome GetSqlInjectionMatchSet(const Model::GetSqlInjectionMatchSetRequest& request) const;
 
  template <typename GetSqlInjectionMatchSetRequestT = Model::GetSqlInjectionMatchSetRequest>
  Model::GetSqlInjectionMatchSetOutcomeCallable GetSqlInjectionMatchSetCallable(const GetSqlInjectionMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetSqlInjectionMatchSet, request);
  }
 
  template <typename GetSqlInjectionMatchSetRequestT = Model::GetSqlInjectionMatchSetRequest>
  void GetSqlInjectionMatchSetAsync(const GetSqlInjectionMatchSetRequestT& request,
                                    const GetSqlInjectionMatchSetResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetSqlInjectionMatchSet, request, handler, context);
  }
 
  virtual Model::GetWebACLOutcome GetWebACL(const Model::GetWebACLRequest& request) const;
 
  template <typename GetWebACLRequestT = Model::GetWebACLRequest>
  Model::GetWebACLOutcomeCallable GetWebACLCallable(const GetWebACLRequestT& request) const {
    return SubmitCallable(&WAFClient::GetWebACL, request);
  }
 
  template <typename GetWebACLRequestT = Model::GetWebACLRequest>
  void GetWebACLAsync(const GetWebACLRequestT& request, const GetWebACLResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetWebACL, request, handler, context);
  }
 
  virtual Model::GetXssMatchSetOutcome GetXssMatchSet(const Model::GetXssMatchSetRequest& request) const;
 
  template <typename GetXssMatchSetRequestT = Model::GetXssMatchSetRequest>
  Model::GetXssMatchSetOutcomeCallable GetXssMatchSetCallable(const GetXssMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::GetXssMatchSet, request);
  }
 
  template <typename GetXssMatchSetRequestT = Model::GetXssMatchSetRequest>
  void GetXssMatchSetAsync(const GetXssMatchSetRequestT& request, const GetXssMatchSetResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::GetXssMatchSet, request, handler, context);
  }
 
  virtual Model::ListActivatedRulesInRuleGroupOutcome ListActivatedRulesInRuleGroup(
      const Model::ListActivatedRulesInRuleGroupRequest& request = {}) const;
 
  template <typename ListActivatedRulesInRuleGroupRequestT = Model::ListActivatedRulesInRuleGroupRequest>
  Model::ListActivatedRulesInRuleGroupOutcomeCallable ListActivatedRulesInRuleGroupCallable(
      const ListActivatedRulesInRuleGroupRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListActivatedRulesInRuleGroup, request);
  }
 
  template <typename ListActivatedRulesInRuleGroupRequestT = Model::ListActivatedRulesInRuleGroupRequest>
  void ListActivatedRulesInRuleGroupAsync(const ListActivatedRulesInRuleGroupResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const ListActivatedRulesInRuleGroupRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListActivatedRulesInRuleGroup, request, handler, context);
  }
 
  virtual Model::ListByteMatchSetsOutcome ListByteMatchSets(const Model::ListByteMatchSetsRequest& request = {}) const;
 
  template <typename ListByteMatchSetsRequestT = Model::ListByteMatchSetsRequest>
  Model::ListByteMatchSetsOutcomeCallable ListByteMatchSetsCallable(const ListByteMatchSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListByteMatchSets, request);
  }
 
  template <typename ListByteMatchSetsRequestT = Model::ListByteMatchSetsRequest>
  void ListByteMatchSetsAsync(const ListByteMatchSetsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListByteMatchSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListByteMatchSets, request, handler, context);
  }
 
  virtual Model::ListGeoMatchSetsOutcome ListGeoMatchSets(const Model::ListGeoMatchSetsRequest& request = {}) const;
 
  template <typename ListGeoMatchSetsRequestT = Model::ListGeoMatchSetsRequest>
  Model::ListGeoMatchSetsOutcomeCallable ListGeoMatchSetsCallable(const ListGeoMatchSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListGeoMatchSets, request);
  }
 
  template <typename ListGeoMatchSetsRequestT = Model::ListGeoMatchSetsRequest>
  void ListGeoMatchSetsAsync(const ListGeoMatchSetsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListGeoMatchSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListGeoMatchSets, request, handler, context);
  }
 
  virtual Model::ListIPSetsOutcome ListIPSets(const Model::ListIPSetsRequest& request = {}) const;
 
  template <typename ListIPSetsRequestT = Model::ListIPSetsRequest>
  Model::ListIPSetsOutcomeCallable ListIPSetsCallable(const ListIPSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListIPSets, request);
  }
 
  template <typename ListIPSetsRequestT = Model::ListIPSetsRequest>
  void ListIPSetsAsync(const ListIPSetsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListIPSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListIPSets, request, handler, context);
  }
 
  virtual Model::ListLoggingConfigurationsOutcome ListLoggingConfigurations(
      const Model::ListLoggingConfigurationsRequest& request = {}) const;
 
  template <typename ListLoggingConfigurationsRequestT = Model::ListLoggingConfigurationsRequest>
  Model::ListLoggingConfigurationsOutcomeCallable ListLoggingConfigurationsCallable(
      const ListLoggingConfigurationsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListLoggingConfigurations, request);
  }
 
  template <typename ListLoggingConfigurationsRequestT = Model::ListLoggingConfigurationsRequest>
  void ListLoggingConfigurationsAsync(const ListLoggingConfigurationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListLoggingConfigurationsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListLoggingConfigurations, request, handler, context);
  }
 
  virtual Model::ListRateBasedRulesOutcome ListRateBasedRules(const Model::ListRateBasedRulesRequest& request = {}) const;
 
  template <typename ListRateBasedRulesRequestT = Model::ListRateBasedRulesRequest>
  Model::ListRateBasedRulesOutcomeCallable ListRateBasedRulesCallable(const ListRateBasedRulesRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListRateBasedRules, request);
  }
 
  template <typename ListRateBasedRulesRequestT = Model::ListRateBasedRulesRequest>
  void ListRateBasedRulesAsync(const ListRateBasedRulesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListRateBasedRulesRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListRateBasedRules, request, handler, context);
  }
 
  virtual Model::ListRegexMatchSetsOutcome ListRegexMatchSets(const Model::ListRegexMatchSetsRequest& request = {}) const;
 
  template <typename ListRegexMatchSetsRequestT = Model::ListRegexMatchSetsRequest>
  Model::ListRegexMatchSetsOutcomeCallable ListRegexMatchSetsCallable(const ListRegexMatchSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListRegexMatchSets, request);
  }
 
  template <typename ListRegexMatchSetsRequestT = Model::ListRegexMatchSetsRequest>
  void ListRegexMatchSetsAsync(const ListRegexMatchSetsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListRegexMatchSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListRegexMatchSets, request, handler, context);
  }
 
  virtual Model::ListRegexPatternSetsOutcome ListRegexPatternSets(const Model::ListRegexPatternSetsRequest& request = {}) const;
 
  template <typename ListRegexPatternSetsRequestT = Model::ListRegexPatternSetsRequest>
  Model::ListRegexPatternSetsOutcomeCallable ListRegexPatternSetsCallable(const ListRegexPatternSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListRegexPatternSets, request);
  }
 
  template <typename ListRegexPatternSetsRequestT = Model::ListRegexPatternSetsRequest>
  void ListRegexPatternSetsAsync(const ListRegexPatternSetsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListRegexPatternSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListRegexPatternSets, request, handler, context);
  }
 
  virtual Model::ListRuleGroupsOutcome ListRuleGroups(const Model::ListRuleGroupsRequest& request = {}) const;
 
  template <typename ListRuleGroupsRequestT = Model::ListRuleGroupsRequest>
  Model::ListRuleGroupsOutcomeCallable ListRuleGroupsCallable(const ListRuleGroupsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListRuleGroups, request);
  }
 
  template <typename ListRuleGroupsRequestT = Model::ListRuleGroupsRequest>
  void ListRuleGroupsAsync(const ListRuleGroupsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListRuleGroupsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListRuleGroups, request, handler, context);
  }
 
  virtual Model::ListRulesOutcome ListRules(const Model::ListRulesRequest& request = {}) const;
 
  template <typename ListRulesRequestT = Model::ListRulesRequest>
  Model::ListRulesOutcomeCallable ListRulesCallable(const ListRulesRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListRules, request);
  }
 
  template <typename ListRulesRequestT = Model::ListRulesRequest>
  void ListRulesAsync(const ListRulesResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListRulesRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListRules, request, handler, context);
  }
 
  virtual Model::ListSizeConstraintSetsOutcome ListSizeConstraintSets(const Model::ListSizeConstraintSetsRequest& request = {}) const;
 
  template <typename ListSizeConstraintSetsRequestT = Model::ListSizeConstraintSetsRequest>
  Model::ListSizeConstraintSetsOutcomeCallable ListSizeConstraintSetsCallable(const ListSizeConstraintSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListSizeConstraintSets, request);
  }
 
  template <typename ListSizeConstraintSetsRequestT = Model::ListSizeConstraintSetsRequest>
  void ListSizeConstraintSetsAsync(const ListSizeConstraintSetsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListSizeConstraintSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListSizeConstraintSets, request, handler, context);
  }
 
  virtual Model::ListSqlInjectionMatchSetsOutcome ListSqlInjectionMatchSets(
      const Model::ListSqlInjectionMatchSetsRequest& request = {}) const;
 
  template <typename ListSqlInjectionMatchSetsRequestT = Model::ListSqlInjectionMatchSetsRequest>
  Model::ListSqlInjectionMatchSetsOutcomeCallable ListSqlInjectionMatchSetsCallable(
      const ListSqlInjectionMatchSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListSqlInjectionMatchSets, request);
  }
 
  template <typename ListSqlInjectionMatchSetsRequestT = Model::ListSqlInjectionMatchSetsRequest>
  void ListSqlInjectionMatchSetsAsync(const ListSqlInjectionMatchSetsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListSqlInjectionMatchSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListSqlInjectionMatchSets, request, handler, context);
  }
 
  virtual Model::ListSubscribedRuleGroupsOutcome ListSubscribedRuleGroups(const Model::ListSubscribedRuleGroupsRequest& request = {}) const;
 
  template <typename ListSubscribedRuleGroupsRequestT = Model::ListSubscribedRuleGroupsRequest>
  Model::ListSubscribedRuleGroupsOutcomeCallable ListSubscribedRuleGroupsCallable(
      const ListSubscribedRuleGroupsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListSubscribedRuleGroups, request);
  }
 
  template <typename ListSubscribedRuleGroupsRequestT = Model::ListSubscribedRuleGroupsRequest>
  void ListSubscribedRuleGroupsAsync(const ListSubscribedRuleGroupsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListSubscribedRuleGroupsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListSubscribedRuleGroups, 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(&WAFClient::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(&WAFClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWebACLsOutcome ListWebACLs(const Model::ListWebACLsRequest& request = {}) const;
 
  template <typename ListWebACLsRequestT = Model::ListWebACLsRequest>
  Model::ListWebACLsOutcomeCallable ListWebACLsCallable(const ListWebACLsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListWebACLs, request);
  }
 
  template <typename ListWebACLsRequestT = Model::ListWebACLsRequest>
  void ListWebACLsAsync(const ListWebACLsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListWebACLsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListWebACLs, request, handler, context);
  }
 
  virtual Model::ListXssMatchSetsOutcome ListXssMatchSets(const Model::ListXssMatchSetsRequest& request = {}) const;
 
  template <typename ListXssMatchSetsRequestT = Model::ListXssMatchSetsRequest>
  Model::ListXssMatchSetsOutcomeCallable ListXssMatchSetsCallable(const ListXssMatchSetsRequestT& request = {}) const {
    return SubmitCallable(&WAFClient::ListXssMatchSets, request);
  }
 
  template <typename ListXssMatchSetsRequestT = Model::ListXssMatchSetsRequest>
  void ListXssMatchSetsAsync(const ListXssMatchSetsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListXssMatchSetsRequestT& request = {}) const {
    return SubmitAsync(&WAFClient::ListXssMatchSets, request, handler, context);
  }
 
  virtual Model::PutLoggingConfigurationOutcome PutLoggingConfiguration(const Model::PutLoggingConfigurationRequest& request) const;
 
  template <typename PutLoggingConfigurationRequestT = Model::PutLoggingConfigurationRequest>
  Model::PutLoggingConfigurationOutcomeCallable PutLoggingConfigurationCallable(const PutLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&WAFClient::PutLoggingConfiguration, request);
  }
 
  template <typename PutLoggingConfigurationRequestT = Model::PutLoggingConfigurationRequest>
  void PutLoggingConfigurationAsync(const PutLoggingConfigurationRequestT& request,
                                    const PutLoggingConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::PutLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::PutPermissionPolicyOutcome PutPermissionPolicy(const Model::PutPermissionPolicyRequest& request) const;
 
  template <typename PutPermissionPolicyRequestT = Model::PutPermissionPolicyRequest>
  Model::PutPermissionPolicyOutcomeCallable PutPermissionPolicyCallable(const PutPermissionPolicyRequestT& request) const {
    return SubmitCallable(&WAFClient::PutPermissionPolicy, request);
  }
 
  template <typename PutPermissionPolicyRequestT = Model::PutPermissionPolicyRequest>
  void PutPermissionPolicyAsync(const PutPermissionPolicyRequestT& request, const PutPermissionPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::PutPermissionPolicy, 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(&WAFClient::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(&WAFClient::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(&WAFClient::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(&WAFClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateByteMatchSetOutcome UpdateByteMatchSet(const Model::UpdateByteMatchSetRequest& request) const;
 
  template <typename UpdateByteMatchSetRequestT = Model::UpdateByteMatchSetRequest>
  Model::UpdateByteMatchSetOutcomeCallable UpdateByteMatchSetCallable(const UpdateByteMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateByteMatchSet, request);
  }
 
  template <typename UpdateByteMatchSetRequestT = Model::UpdateByteMatchSetRequest>
  void UpdateByteMatchSetAsync(const UpdateByteMatchSetRequestT& request, const UpdateByteMatchSetResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateByteMatchSet, request, handler, context);
  }
 
  virtual Model::UpdateGeoMatchSetOutcome UpdateGeoMatchSet(const Model::UpdateGeoMatchSetRequest& request) const;
 
  template <typename UpdateGeoMatchSetRequestT = Model::UpdateGeoMatchSetRequest>
  Model::UpdateGeoMatchSetOutcomeCallable UpdateGeoMatchSetCallable(const UpdateGeoMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateGeoMatchSet, request);
  }
 
  template <typename UpdateGeoMatchSetRequestT = Model::UpdateGeoMatchSetRequest>
  void UpdateGeoMatchSetAsync(const UpdateGeoMatchSetRequestT& request, const UpdateGeoMatchSetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateGeoMatchSet, request, handler, context);
  }
 
  virtual Model::UpdateIPSetOutcome UpdateIPSet(const Model::UpdateIPSetRequest& request) const;
 
  template <typename UpdateIPSetRequestT = Model::UpdateIPSetRequest>
  Model::UpdateIPSetOutcomeCallable UpdateIPSetCallable(const UpdateIPSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateIPSet, request);
  }
 
  template <typename UpdateIPSetRequestT = Model::UpdateIPSetRequest>
  void UpdateIPSetAsync(const UpdateIPSetRequestT& request, const UpdateIPSetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateIPSet, request, handler, context);
  }
 
  virtual Model::UpdateRateBasedRuleOutcome UpdateRateBasedRule(const Model::UpdateRateBasedRuleRequest& request) const;
 
  template <typename UpdateRateBasedRuleRequestT = Model::UpdateRateBasedRuleRequest>
  Model::UpdateRateBasedRuleOutcomeCallable UpdateRateBasedRuleCallable(const UpdateRateBasedRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateRateBasedRule, request);
  }
 
  template <typename UpdateRateBasedRuleRequestT = Model::UpdateRateBasedRuleRequest>
  void UpdateRateBasedRuleAsync(const UpdateRateBasedRuleRequestT& request, const UpdateRateBasedRuleResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateRateBasedRule, request, handler, context);
  }
 
  virtual Model::UpdateRegexMatchSetOutcome UpdateRegexMatchSet(const Model::UpdateRegexMatchSetRequest& request) const;
 
  template <typename UpdateRegexMatchSetRequestT = Model::UpdateRegexMatchSetRequest>
  Model::UpdateRegexMatchSetOutcomeCallable UpdateRegexMatchSetCallable(const UpdateRegexMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateRegexMatchSet, request);
  }
 
  template <typename UpdateRegexMatchSetRequestT = Model::UpdateRegexMatchSetRequest>
  void UpdateRegexMatchSetAsync(const UpdateRegexMatchSetRequestT& request, const UpdateRegexMatchSetResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateRegexMatchSet, request, handler, context);
  }
 
  virtual Model::UpdateRegexPatternSetOutcome UpdateRegexPatternSet(const Model::UpdateRegexPatternSetRequest& request) const;
 
  template <typename UpdateRegexPatternSetRequestT = Model::UpdateRegexPatternSetRequest>
  Model::UpdateRegexPatternSetOutcomeCallable UpdateRegexPatternSetCallable(const UpdateRegexPatternSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateRegexPatternSet, request);
  }
 
  template <typename UpdateRegexPatternSetRequestT = Model::UpdateRegexPatternSetRequest>
  void UpdateRegexPatternSetAsync(const UpdateRegexPatternSetRequestT& request, const UpdateRegexPatternSetResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateRegexPatternSet, request, handler, context);
  }
 
  virtual Model::UpdateRuleOutcome UpdateRule(const Model::UpdateRuleRequest& request) const;
 
  template <typename UpdateRuleRequestT = Model::UpdateRuleRequest>
  Model::UpdateRuleOutcomeCallable UpdateRuleCallable(const UpdateRuleRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateRule, request);
  }
 
  template <typename UpdateRuleRequestT = Model::UpdateRuleRequest>
  void UpdateRuleAsync(const UpdateRuleRequestT& request, const UpdateRuleResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateRule, request, handler, context);
  }
 
  virtual Model::UpdateRuleGroupOutcome UpdateRuleGroup(const Model::UpdateRuleGroupRequest& request) const;
 
  template <typename UpdateRuleGroupRequestT = Model::UpdateRuleGroupRequest>
  Model::UpdateRuleGroupOutcomeCallable UpdateRuleGroupCallable(const UpdateRuleGroupRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateRuleGroup, request);
  }
 
  template <typename UpdateRuleGroupRequestT = Model::UpdateRuleGroupRequest>
  void UpdateRuleGroupAsync(const UpdateRuleGroupRequestT& request, const UpdateRuleGroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateRuleGroup, request, handler, context);
  }
 
  virtual Model::UpdateSizeConstraintSetOutcome UpdateSizeConstraintSet(const Model::UpdateSizeConstraintSetRequest& request) const;
 
  template <typename UpdateSizeConstraintSetRequestT = Model::UpdateSizeConstraintSetRequest>
  Model::UpdateSizeConstraintSetOutcomeCallable UpdateSizeConstraintSetCallable(const UpdateSizeConstraintSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateSizeConstraintSet, request);
  }
 
  template <typename UpdateSizeConstraintSetRequestT = Model::UpdateSizeConstraintSetRequest>
  void UpdateSizeConstraintSetAsync(const UpdateSizeConstraintSetRequestT& request,
                                    const UpdateSizeConstraintSetResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateSizeConstraintSet, request, handler, context);
  }
 
  virtual Model::UpdateSqlInjectionMatchSetOutcome UpdateSqlInjectionMatchSet(
      const Model::UpdateSqlInjectionMatchSetRequest& request) const;
 
  template <typename UpdateSqlInjectionMatchSetRequestT = Model::UpdateSqlInjectionMatchSetRequest>
  Model::UpdateSqlInjectionMatchSetOutcomeCallable UpdateSqlInjectionMatchSetCallable(
      const UpdateSqlInjectionMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateSqlInjectionMatchSet, request);
  }
 
  template <typename UpdateSqlInjectionMatchSetRequestT = Model::UpdateSqlInjectionMatchSetRequest>
  void UpdateSqlInjectionMatchSetAsync(const UpdateSqlInjectionMatchSetRequestT& request,
                                       const UpdateSqlInjectionMatchSetResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateSqlInjectionMatchSet, request, handler, context);
  }
 
  virtual Model::UpdateWebACLOutcome UpdateWebACL(const Model::UpdateWebACLRequest& request) const;
 
  template <typename UpdateWebACLRequestT = Model::UpdateWebACLRequest>
  Model::UpdateWebACLOutcomeCallable UpdateWebACLCallable(const UpdateWebACLRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateWebACL, request);
  }
 
  template <typename UpdateWebACLRequestT = Model::UpdateWebACLRequest>
  void UpdateWebACLAsync(const UpdateWebACLRequestT& request, const UpdateWebACLResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateWebACL, request, handler, context);
  }
 
  virtual Model::UpdateXssMatchSetOutcome UpdateXssMatchSet(const Model::UpdateXssMatchSetRequest& request) const;
 
  template <typename UpdateXssMatchSetRequestT = Model::UpdateXssMatchSetRequest>
  Model::UpdateXssMatchSetOutcomeCallable UpdateXssMatchSetCallable(const UpdateXssMatchSetRequestT& request) const {
    return SubmitCallable(&WAFClient::UpdateXssMatchSet, request);
  }
 
  template <typename UpdateXssMatchSetRequestT = Model::UpdateXssMatchSetRequest>
  void UpdateXssMatchSetAsync(const UpdateXssMatchSetRequestT& request, const UpdateXssMatchSetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&WAFClient::UpdateXssMatchSet, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<WAFEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<WAFClient>;
  void init(const WAFClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, WAFError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  WAFClientConfiguration m_clientConfiguration;
  std::shared_ptr<WAFEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace WAF
}  // namespace Aws