WAFClient.h

 
#pragma once
#include <aws/waf/WAF_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/waf/WAFServiceClientModel.h>
 
namespace Aws
{
namespace WAF
{
  class AWS_WAF_API WAFClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<WAFEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<WAFClient>;
      void init(const WAFClientConfiguration& clientConfiguration);
 
      WAFClientConfiguration m_clientConfiguration;
      std::shared_ptr<WAFEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace WAF
} // namespace Aws