WAFV2Client.h

 
#pragma once
#include <aws/wafv2/WAFV2_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/wafv2/WAFV2ServiceClientModel.h>
 
namespace Aws
{
namespace WAFV2
{
  class AWS_WAFV2_API WAFV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<WAFV2Client>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef WAFV2ClientConfiguration ClientConfigurationType;
      typedef WAFV2EndpointProvider EndpointProviderType;
 
        WAFV2Client(const Aws::WAFV2::WAFV2ClientConfiguration& clientConfiguration = Aws::WAFV2::WAFV2ClientConfiguration(),
                    std::shared_ptr<WAFV2EndpointProviderBase> endpointProvider = nullptr);
 
        WAFV2Client(const Aws::Auth::AWSCredentials& credentials,
                    std::shared_ptr<WAFV2EndpointProviderBase> endpointProvider = nullptr,
                    const Aws::WAFV2::WAFV2ClientConfiguration& clientConfiguration = Aws::WAFV2::WAFV2ClientConfiguration());
 
        WAFV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    std::shared_ptr<WAFV2EndpointProviderBase> endpointProvider = nullptr,
                    const Aws::WAFV2::WAFV2ClientConfiguration& clientConfiguration = Aws::WAFV2::WAFV2ClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        WAFV2Client(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WAFV2Client(const Aws::Auth::AWSCredentials& credentials,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WAFV2Client(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~WAFV2Client();
 
        virtual Model::AssociateWebACLOutcome AssociateWebACL(const Model::AssociateWebACLRequest& request) const;
 
        template<typename AssociateWebACLRequestT = Model::AssociateWebACLRequest>
        Model::AssociateWebACLOutcomeCallable AssociateWebACLCallable(const AssociateWebACLRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::AssociateWebACL, request);
        }
 
        template<typename AssociateWebACLRequestT = Model::AssociateWebACLRequest>
        void AssociateWebACLAsync(const AssociateWebACLRequestT& request, const AssociateWebACLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::AssociateWebACL, request, handler, context);
        }
 
        virtual Model::CheckCapacityOutcome CheckCapacity(const Model::CheckCapacityRequest& request) const;
 
        template<typename CheckCapacityRequestT = Model::CheckCapacityRequest>
        Model::CheckCapacityOutcomeCallable CheckCapacityCallable(const CheckCapacityRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::CheckCapacity, request);
        }
 
        template<typename CheckCapacityRequestT = Model::CheckCapacityRequest>
        void CheckCapacityAsync(const CheckCapacityRequestT& request, const CheckCapacityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::CheckCapacity, request, handler, context);
        }
 
        virtual Model::CreateAPIKeyOutcome CreateAPIKey(const Model::CreateAPIKeyRequest& request) const;
 
        template<typename CreateAPIKeyRequestT = Model::CreateAPIKeyRequest>
        Model::CreateAPIKeyOutcomeCallable CreateAPIKeyCallable(const CreateAPIKeyRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::CreateAPIKey, request);
        }
 
        template<typename CreateAPIKeyRequestT = Model::CreateAPIKeyRequest>
        void CreateAPIKeyAsync(const CreateAPIKeyRequestT& request, const CreateAPIKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::CreateAPIKey, 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(&WAFV2Client::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(&WAFV2Client::CreateIPSet, 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(&WAFV2Client::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(&WAFV2Client::CreateRegexPatternSet, 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(&WAFV2Client::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(&WAFV2Client::CreateRuleGroup, 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(&WAFV2Client::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(&WAFV2Client::CreateWebACL, request, handler, context);
        }
 
        virtual Model::DeleteAPIKeyOutcome DeleteAPIKey(const Model::DeleteAPIKeyRequest& request) const;
 
        template<typename DeleteAPIKeyRequestT = Model::DeleteAPIKeyRequest>
        Model::DeleteAPIKeyOutcomeCallable DeleteAPIKeyCallable(const DeleteAPIKeyRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::DeleteAPIKey, request);
        }
 
        template<typename DeleteAPIKeyRequestT = Model::DeleteAPIKeyRequest>
        void DeleteAPIKeyAsync(const DeleteAPIKeyRequestT& request, const DeleteAPIKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::DeleteAPIKey, request, handler, context);
        }
 
        virtual Model::DeleteFirewallManagerRuleGroupsOutcome DeleteFirewallManagerRuleGroups(const Model::DeleteFirewallManagerRuleGroupsRequest& request) const;
 
        template<typename DeleteFirewallManagerRuleGroupsRequestT = Model::DeleteFirewallManagerRuleGroupsRequest>
        Model::DeleteFirewallManagerRuleGroupsOutcomeCallable DeleteFirewallManagerRuleGroupsCallable(const DeleteFirewallManagerRuleGroupsRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::DeleteFirewallManagerRuleGroups, request);
        }
 
        template<typename DeleteFirewallManagerRuleGroupsRequestT = Model::DeleteFirewallManagerRuleGroupsRequest>
        void DeleteFirewallManagerRuleGroupsAsync(const DeleteFirewallManagerRuleGroupsRequestT& request, const DeleteFirewallManagerRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::DeleteFirewallManagerRuleGroups, 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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::DeletePermissionPolicy, 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(&WAFV2Client::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(&WAFV2Client::DeleteRegexPatternSet, 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(&WAFV2Client::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(&WAFV2Client::DeleteRuleGroup, 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(&WAFV2Client::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(&WAFV2Client::DeleteWebACL, request, handler, context);
        }
 
        virtual Model::DescribeAllManagedProductsOutcome DescribeAllManagedProducts(const Model::DescribeAllManagedProductsRequest& request) const;
 
        template<typename DescribeAllManagedProductsRequestT = Model::DescribeAllManagedProductsRequest>
        Model::DescribeAllManagedProductsOutcomeCallable DescribeAllManagedProductsCallable(const DescribeAllManagedProductsRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::DescribeAllManagedProducts, request);
        }
 
        template<typename DescribeAllManagedProductsRequestT = Model::DescribeAllManagedProductsRequest>
        void DescribeAllManagedProductsAsync(const DescribeAllManagedProductsRequestT& request, const DescribeAllManagedProductsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::DescribeAllManagedProducts, request, handler, context);
        }
 
        virtual Model::DescribeManagedProductsByVendorOutcome DescribeManagedProductsByVendor(const Model::DescribeManagedProductsByVendorRequest& request) const;
 
        template<typename DescribeManagedProductsByVendorRequestT = Model::DescribeManagedProductsByVendorRequest>
        Model::DescribeManagedProductsByVendorOutcomeCallable DescribeManagedProductsByVendorCallable(const DescribeManagedProductsByVendorRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::DescribeManagedProductsByVendor, request);
        }
 
        template<typename DescribeManagedProductsByVendorRequestT = Model::DescribeManagedProductsByVendorRequest>
        void DescribeManagedProductsByVendorAsync(const DescribeManagedProductsByVendorRequestT& request, const DescribeManagedProductsByVendorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::DescribeManagedProductsByVendor, request, handler, context);
        }
 
        virtual Model::DescribeManagedRuleGroupOutcome DescribeManagedRuleGroup(const Model::DescribeManagedRuleGroupRequest& request) const;
 
        template<typename DescribeManagedRuleGroupRequestT = Model::DescribeManagedRuleGroupRequest>
        Model::DescribeManagedRuleGroupOutcomeCallable DescribeManagedRuleGroupCallable(const DescribeManagedRuleGroupRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::DescribeManagedRuleGroup, request);
        }
 
        template<typename DescribeManagedRuleGroupRequestT = Model::DescribeManagedRuleGroupRequest>
        void DescribeManagedRuleGroupAsync(const DescribeManagedRuleGroupRequestT& request, const DescribeManagedRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::DescribeManagedRuleGroup, request, handler, context);
        }
 
        virtual Model::DisassociateWebACLOutcome DisassociateWebACL(const Model::DisassociateWebACLRequest& request) const;
 
        template<typename DisassociateWebACLRequestT = Model::DisassociateWebACLRequest>
        Model::DisassociateWebACLOutcomeCallable DisassociateWebACLCallable(const DisassociateWebACLRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::DisassociateWebACL, request);
        }
 
        template<typename DisassociateWebACLRequestT = Model::DisassociateWebACLRequest>
        void DisassociateWebACLAsync(const DisassociateWebACLRequestT& request, const DisassociateWebACLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::DisassociateWebACL, request, handler, context);
        }
 
        virtual Model::GenerateMobileSdkReleaseUrlOutcome GenerateMobileSdkReleaseUrl(const Model::GenerateMobileSdkReleaseUrlRequest& request) const;
 
        template<typename GenerateMobileSdkReleaseUrlRequestT = Model::GenerateMobileSdkReleaseUrlRequest>
        Model::GenerateMobileSdkReleaseUrlOutcomeCallable GenerateMobileSdkReleaseUrlCallable(const GenerateMobileSdkReleaseUrlRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::GenerateMobileSdkReleaseUrl, request);
        }
 
        template<typename GenerateMobileSdkReleaseUrlRequestT = Model::GenerateMobileSdkReleaseUrlRequest>
        void GenerateMobileSdkReleaseUrlAsync(const GenerateMobileSdkReleaseUrlRequestT& request, const GenerateMobileSdkReleaseUrlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::GenerateMobileSdkReleaseUrl, request, handler, context);
        }
 
        virtual Model::GetDecryptedAPIKeyOutcome GetDecryptedAPIKey(const Model::GetDecryptedAPIKeyRequest& request) const;
 
        template<typename GetDecryptedAPIKeyRequestT = Model::GetDecryptedAPIKeyRequest>
        Model::GetDecryptedAPIKeyOutcomeCallable GetDecryptedAPIKeyCallable(const GetDecryptedAPIKeyRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::GetDecryptedAPIKey, request);
        }
 
        template<typename GetDecryptedAPIKeyRequestT = Model::GetDecryptedAPIKeyRequest>
        void GetDecryptedAPIKeyAsync(const GetDecryptedAPIKeyRequestT& request, const GetDecryptedAPIKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::GetDecryptedAPIKey, 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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::GetLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::GetManagedRuleSetOutcome GetManagedRuleSet(const Model::GetManagedRuleSetRequest& request) const;
 
        template<typename GetManagedRuleSetRequestT = Model::GetManagedRuleSetRequest>
        Model::GetManagedRuleSetOutcomeCallable GetManagedRuleSetCallable(const GetManagedRuleSetRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::GetManagedRuleSet, request);
        }
 
        template<typename GetManagedRuleSetRequestT = Model::GetManagedRuleSetRequest>
        void GetManagedRuleSetAsync(const GetManagedRuleSetRequestT& request, const GetManagedRuleSetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::GetManagedRuleSet, request, handler, context);
        }
 
        virtual Model::GetMobileSdkReleaseOutcome GetMobileSdkRelease(const Model::GetMobileSdkReleaseRequest& request) const;
 
        template<typename GetMobileSdkReleaseRequestT = Model::GetMobileSdkReleaseRequest>
        Model::GetMobileSdkReleaseOutcomeCallable GetMobileSdkReleaseCallable(const GetMobileSdkReleaseRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::GetMobileSdkRelease, request);
        }
 
        template<typename GetMobileSdkReleaseRequestT = Model::GetMobileSdkReleaseRequest>
        void GetMobileSdkReleaseAsync(const GetMobileSdkReleaseRequestT& request, const GetMobileSdkReleaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::GetMobileSdkRelease, 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(&WAFV2Client::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(&WAFV2Client::GetPermissionPolicy, request, handler, context);
        }
 
        virtual Model::GetRateBasedStatementManagedKeysOutcome GetRateBasedStatementManagedKeys(const Model::GetRateBasedStatementManagedKeysRequest& request) const;
 
        template<typename GetRateBasedStatementManagedKeysRequestT = Model::GetRateBasedStatementManagedKeysRequest>
        Model::GetRateBasedStatementManagedKeysOutcomeCallable GetRateBasedStatementManagedKeysCallable(const GetRateBasedStatementManagedKeysRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::GetRateBasedStatementManagedKeys, request);
        }
 
        template<typename GetRateBasedStatementManagedKeysRequestT = Model::GetRateBasedStatementManagedKeysRequest>
        void GetRateBasedStatementManagedKeysAsync(const GetRateBasedStatementManagedKeysRequestT& request, const GetRateBasedStatementManagedKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::GetRateBasedStatementManagedKeys, 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(&WAFV2Client::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(&WAFV2Client::GetRegexPatternSet, 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(&WAFV2Client::GetRuleGroup, request);
        }
 
        template<typename GetRuleGroupRequestT = Model::GetRuleGroupRequest>
        void GetRuleGroupAsync(const GetRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetRuleGroupRequestT& request = {}) const
        {
            return SubmitAsync(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::GetSampledRequests, 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(&WAFV2Client::GetWebACL, request);
        }
 
        template<typename GetWebACLRequestT = Model::GetWebACLRequest>
        void GetWebACLAsync(const GetWebACLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetWebACLRequestT& request = {}) const
        {
            return SubmitAsync(&WAFV2Client::GetWebACL, request, handler, context);
        }
 
        virtual Model::GetWebACLForResourceOutcome GetWebACLForResource(const Model::GetWebACLForResourceRequest& request) const;
 
        template<typename GetWebACLForResourceRequestT = Model::GetWebACLForResourceRequest>
        Model::GetWebACLForResourceOutcomeCallable GetWebACLForResourceCallable(const GetWebACLForResourceRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::GetWebACLForResource, request);
        }
 
        template<typename GetWebACLForResourceRequestT = Model::GetWebACLForResourceRequest>
        void GetWebACLForResourceAsync(const GetWebACLForResourceRequestT& request, const GetWebACLForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::GetWebACLForResource, request, handler, context);
        }
 
        virtual Model::ListAPIKeysOutcome ListAPIKeys(const Model::ListAPIKeysRequest& request) const;
 
        template<typename ListAPIKeysRequestT = Model::ListAPIKeysRequest>
        Model::ListAPIKeysOutcomeCallable ListAPIKeysCallable(const ListAPIKeysRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::ListAPIKeys, request);
        }
 
        template<typename ListAPIKeysRequestT = Model::ListAPIKeysRequest>
        void ListAPIKeysAsync(const ListAPIKeysRequestT& request, const ListAPIKeysResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListAPIKeys, request, handler, context);
        }
 
        virtual Model::ListAvailableManagedRuleGroupVersionsOutcome ListAvailableManagedRuleGroupVersions(const Model::ListAvailableManagedRuleGroupVersionsRequest& request) const;
 
        template<typename ListAvailableManagedRuleGroupVersionsRequestT = Model::ListAvailableManagedRuleGroupVersionsRequest>
        Model::ListAvailableManagedRuleGroupVersionsOutcomeCallable ListAvailableManagedRuleGroupVersionsCallable(const ListAvailableManagedRuleGroupVersionsRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::ListAvailableManagedRuleGroupVersions, request);
        }
 
        template<typename ListAvailableManagedRuleGroupVersionsRequestT = Model::ListAvailableManagedRuleGroupVersionsRequest>
        void ListAvailableManagedRuleGroupVersionsAsync(const ListAvailableManagedRuleGroupVersionsRequestT& request, const ListAvailableManagedRuleGroupVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListAvailableManagedRuleGroupVersions, request, handler, context);
        }
 
        virtual Model::ListAvailableManagedRuleGroupsOutcome ListAvailableManagedRuleGroups(const Model::ListAvailableManagedRuleGroupsRequest& request) const;
 
        template<typename ListAvailableManagedRuleGroupsRequestT = Model::ListAvailableManagedRuleGroupsRequest>
        Model::ListAvailableManagedRuleGroupsOutcomeCallable ListAvailableManagedRuleGroupsCallable(const ListAvailableManagedRuleGroupsRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::ListAvailableManagedRuleGroups, request);
        }
 
        template<typename ListAvailableManagedRuleGroupsRequestT = Model::ListAvailableManagedRuleGroupsRequest>
        void ListAvailableManagedRuleGroupsAsync(const ListAvailableManagedRuleGroupsRequestT& request, const ListAvailableManagedRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListAvailableManagedRuleGroups, 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(&WAFV2Client::ListIPSets, request);
        }
 
        template<typename ListIPSetsRequestT = Model::ListIPSetsRequest>
        void ListIPSetsAsync(const ListIPSetsRequestT& request, const ListIPSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::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(&WAFV2Client::ListLoggingConfigurations, request);
        }
 
        template<typename ListLoggingConfigurationsRequestT = Model::ListLoggingConfigurationsRequest>
        void ListLoggingConfigurationsAsync(const ListLoggingConfigurationsRequestT& request, const ListLoggingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListLoggingConfigurations, request, handler, context);
        }
 
        virtual Model::ListManagedRuleSetsOutcome ListManagedRuleSets(const Model::ListManagedRuleSetsRequest& request) const;
 
        template<typename ListManagedRuleSetsRequestT = Model::ListManagedRuleSetsRequest>
        Model::ListManagedRuleSetsOutcomeCallable ListManagedRuleSetsCallable(const ListManagedRuleSetsRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::ListManagedRuleSets, request);
        }
 
        template<typename ListManagedRuleSetsRequestT = Model::ListManagedRuleSetsRequest>
        void ListManagedRuleSetsAsync(const ListManagedRuleSetsRequestT& request, const ListManagedRuleSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListManagedRuleSets, request, handler, context);
        }
 
        virtual Model::ListMobileSdkReleasesOutcome ListMobileSdkReleases(const Model::ListMobileSdkReleasesRequest& request) const;
 
        template<typename ListMobileSdkReleasesRequestT = Model::ListMobileSdkReleasesRequest>
        Model::ListMobileSdkReleasesOutcomeCallable ListMobileSdkReleasesCallable(const ListMobileSdkReleasesRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::ListMobileSdkReleases, request);
        }
 
        template<typename ListMobileSdkReleasesRequestT = Model::ListMobileSdkReleasesRequest>
        void ListMobileSdkReleasesAsync(const ListMobileSdkReleasesRequestT& request, const ListMobileSdkReleasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListMobileSdkReleases, 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(&WAFV2Client::ListRegexPatternSets, request);
        }
 
        template<typename ListRegexPatternSetsRequestT = Model::ListRegexPatternSetsRequest>
        void ListRegexPatternSetsAsync(const ListRegexPatternSetsRequestT& request, const ListRegexPatternSetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListRegexPatternSets, request, handler, context);
        }
 
        virtual Model::ListResourcesForWebACLOutcome ListResourcesForWebACL(const Model::ListResourcesForWebACLRequest& request) const;
 
        template<typename ListResourcesForWebACLRequestT = Model::ListResourcesForWebACLRequest>
        Model::ListResourcesForWebACLOutcomeCallable ListResourcesForWebACLCallable(const ListResourcesForWebACLRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::ListResourcesForWebACL, request);
        }
 
        template<typename ListResourcesForWebACLRequestT = Model::ListResourcesForWebACLRequest>
        void ListResourcesForWebACLAsync(const ListResourcesForWebACLRequestT& request, const ListResourcesForWebACLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListResourcesForWebACL, 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(&WAFV2Client::ListRuleGroups, request);
        }
 
        template<typename ListRuleGroupsRequestT = Model::ListRuleGroupsRequest>
        void ListRuleGroupsAsync(const ListRuleGroupsRequestT& request, const ListRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListRuleGroups, 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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::ListWebACLs, request);
        }
 
        template<typename ListWebACLsRequestT = Model::ListWebACLsRequest>
        void ListWebACLsAsync(const ListWebACLsRequestT& request, const ListWebACLsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::ListWebACLs, 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(&WAFV2Client::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(&WAFV2Client::PutLoggingConfiguration, request, handler, context);
        }
 
        virtual Model::PutManagedRuleSetVersionsOutcome PutManagedRuleSetVersions(const Model::PutManagedRuleSetVersionsRequest& request) const;
 
        template<typename PutManagedRuleSetVersionsRequestT = Model::PutManagedRuleSetVersionsRequest>
        Model::PutManagedRuleSetVersionsOutcomeCallable PutManagedRuleSetVersionsCallable(const PutManagedRuleSetVersionsRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::PutManagedRuleSetVersions, request);
        }
 
        template<typename PutManagedRuleSetVersionsRequestT = Model::PutManagedRuleSetVersionsRequest>
        void PutManagedRuleSetVersionsAsync(const PutManagedRuleSetVersionsRequestT& request, const PutManagedRuleSetVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::PutManagedRuleSetVersions, 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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::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(&WAFV2Client::UntagResource, 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(&WAFV2Client::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(&WAFV2Client::UpdateIPSet, request, handler, context);
        }
 
        virtual Model::UpdateManagedRuleSetVersionExpiryDateOutcome UpdateManagedRuleSetVersionExpiryDate(const Model::UpdateManagedRuleSetVersionExpiryDateRequest& request) const;
 
        template<typename UpdateManagedRuleSetVersionExpiryDateRequestT = Model::UpdateManagedRuleSetVersionExpiryDateRequest>
        Model::UpdateManagedRuleSetVersionExpiryDateOutcomeCallable UpdateManagedRuleSetVersionExpiryDateCallable(const UpdateManagedRuleSetVersionExpiryDateRequestT& request) const
        {
            return SubmitCallable(&WAFV2Client::UpdateManagedRuleSetVersionExpiryDate, request);
        }
 
        template<typename UpdateManagedRuleSetVersionExpiryDateRequestT = Model::UpdateManagedRuleSetVersionExpiryDateRequest>
        void UpdateManagedRuleSetVersionExpiryDateAsync(const UpdateManagedRuleSetVersionExpiryDateRequestT& request, const UpdateManagedRuleSetVersionExpiryDateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WAFV2Client::UpdateManagedRuleSetVersionExpiryDate, 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(&WAFV2Client::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(&WAFV2Client::UpdateRegexPatternSet, 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(&WAFV2Client::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(&WAFV2Client::UpdateRuleGroup, 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(&WAFV2Client::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(&WAFV2Client::UpdateWebACL, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<WAFV2EndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<WAFV2Client>;
      void init(const WAFV2ClientConfiguration& clientConfiguration);
 
      WAFV2ClientConfiguration m_clientConfiguration;
      std::shared_ptr<WAFV2EndpointProviderBase> m_endpointProvider;
  };
 
} // namespace WAFV2
} // namespace Aws