/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace WAF { /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

This is the AWS WAF * Classic API Reference for using AWS WAF Classic with Amazon CloudFront. The * AWS WAF Classic actions and data types listed in the reference are available for * protecting Amazon CloudFront distributions. You can use these actions and data * types via the endpoint waf.amazonaws.com. This guide is for developers * who need detailed information about the AWS WAF Classic API actions, data types, * and errors. For detailed information about AWS WAF Classic features and an * overview of how to use the AWS WAF Classic API, see the AWS * WAF Classic in the developer guide.

*/ class AWS_WAF_API WAFClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef WAFClientConfiguration ClientConfigurationType; typedef WAFEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WAFClient(const Aws::WAF::WAFClientConfiguration& clientConfiguration = Aws::WAF::WAFClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WAFClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::WAF::WAFClientConfiguration& clientConfiguration = Aws::WAF::WAFClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ WAFClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::WAF::WAFClientConfiguration& clientConfiguration = Aws::WAF::WAFClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WAFClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WAFClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ WAFClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~WAFClient(); /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * ByteMatchSet. You then use UpdateByteMatchSet to identify * the part of a web request that you want AWS WAF to inspect, such as the values * of the User-Agent header or the query string. For example, you can * create a ByteMatchSet that matches any requests with * User-Agent headers that contain the string BadBot. You * can then configure AWS WAF to reject those requests.

To create and * configure a ByteMatchSet, perform the following steps:

    *

  1. Use GetChangeToken to get the change token that you provide in * the ChangeToken parameter of a CreateByteMatchSet * request.

  2. Submit a CreateByteMatchSet request.

    *

  3. Use GetChangeToken to get the change token that you * provide in the ChangeToken parameter of an * UpdateByteMatchSet request.

  4. Submit an * UpdateByteMatchSet request to specify the part of the request that you * want AWS WAF to inspect (for example, the header or the URI) and the value that * you want AWS WAF to watch for.

For more information about how * to use the AWS WAF API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateByteMatchSetOutcome CreateByteMatchSet(const Model::CreateByteMatchSetRequest& request) const; /** * A Callable wrapper for CreateByteMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateByteMatchSetOutcomeCallable CreateByteMatchSetCallable(const CreateByteMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateByteMatchSet, request); } /** * An Async wrapper for CreateByteMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateByteMatchSetAsync(const CreateByteMatchSetRequestT& request, const CreateByteMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateByteMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates an * GeoMatchSet, which you use to specify which web requests you want to * allow or block based on the country that the requests originate from. For * example, if you're receiving a lot of requests from one or more countries and * you want to block the requests, you can create an GeoMatchSet that * contains those countries and then configure AWS WAF to block the requests.

*

To create and configure a GeoMatchSet, perform the following * steps:

  1. Use GetChangeToken to get the change token that * you provide in the ChangeToken parameter of a * CreateGeoMatchSet request.

  2. Submit a * CreateGeoMatchSet request.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateGeoMatchSet request.

    *

  4. Submit an UpdateGeoMatchSetSet request to specify the * countries that you want AWS WAF to watch for.

For more * information about how to use the AWS WAF API to allow or block HTTP requests, * see the AWS WAF * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateGeoMatchSetOutcome CreateGeoMatchSet(const Model::CreateGeoMatchSetRequest& request) const; /** * A Callable wrapper for CreateGeoMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGeoMatchSetOutcomeCallable CreateGeoMatchSetCallable(const CreateGeoMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateGeoMatchSet, request); } /** * An Async wrapper for CreateGeoMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGeoMatchSetAsync(const CreateGeoMatchSetRequestT& request, const CreateGeoMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateGeoMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates an IPSet, * which you use to specify which web requests that you want to allow or block * based on the IP addresses that the requests originate from. For example, if * you're receiving a lot of requests from one or more individual IP addresses or * one or more ranges of IP addresses and you want to block the requests, you can * create an IPSet that contains those IP addresses and then configure * AWS WAF to block the requests.

To create and configure an * IPSet, perform the following steps:

  1. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a CreateIPSet request.

    *

  2. Submit a CreateIPSet request.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateIPSet request.

    4. *

  4. Submit an UpdateIPSet request to specify the IP addresses * that you want AWS WAF to watch for.

For more information * about how to use the AWS WAF API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateIPSetOutcome CreateIPSet(const Model::CreateIPSetRequest& request) const; /** * A Callable wrapper for CreateIPSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIPSetOutcomeCallable CreateIPSetCallable(const CreateIPSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateIPSet, request); } /** * An Async wrapper for CreateIPSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIPSetAsync(const CreateIPSetRequestT& request, const CreateIPSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateIPSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * RateBasedRule. The RateBasedRule contains a * RateLimit, which specifies the maximum number of requests that AWS * WAF allows from a specified IP address in a five-minute period. The * RateBasedRule also contains the IPSet objects, * ByteMatchSet objects, and other predicates that identify the * requests that you want to count or block if these requests exceed the * RateLimit.

If you add more than one predicate to a * RateBasedRule, a request not only must exceed the * RateLimit, but it also must match all the conditions to be counted * or blocked. For example, suppose you add the following to a * RateBasedRule:

  • An IPSet that matches * the IP address 192.0.2.44/32

  • A * ByteMatchSet that matches BadBot in the * User-Agent header

Further, you specify a * RateLimit of 1,000.

You then add the * RateBasedRule to a WebACL and specify that you want to * block requests that meet the conditions in the rule. For a request to be * blocked, it must come from the IP address 192.0.2.44 and the * User-Agent header in the request must contain the value * BadBot. Further, requests that match these two conditions must be * received at a rate of more than 1,000 requests every five minutes. If both * conditions are met and the rate is exceeded, AWS WAF blocks the requests. If the * rate drops below 1,000 for a five-minute period, AWS WAF no longer blocks the * requests.

As a second example, suppose you want to limit requests to a * particular page on your site. To do this, you could add the following to a * RateBasedRule:

  • A ByteMatchSet with * FieldToMatch of URI

  • A * PositionalConstraint of STARTS_WITH

  • *

    A TargetString of login

*

Further, you specify a RateLimit of 1,000.

By adding this * RateBasedRule to a WebACL, you could limit requests to * your login page without affecting the rest of your site.

To create and * configure a RateBasedRule, perform the following steps:

    *

  1. Create and update the predicates that you want to include in the rule. * For more information, see CreateByteMatchSet, CreateIPSet, and * CreateSqlInjectionMatchSet.

  2. Use GetChangeToken * to get the change token that you provide in the ChangeToken * parameter of a CreateRule request.

  3. Submit a * CreateRateBasedRule request.

  4. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateRule request.

    5. *

  5. Submit an UpdateRateBasedRule request to specify the * predicates that you want to include in the rule.

  6. Create and * update a WebACL that contains the RateBasedRule. For * more information, see CreateWebACL.

For more * information about how to use the AWS WAF API to allow or block HTTP requests, * see the AWS WAF * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRateBasedRuleOutcome CreateRateBasedRule(const Model::CreateRateBasedRuleRequest& request) const; /** * A Callable wrapper for CreateRateBasedRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRateBasedRuleOutcomeCallable CreateRateBasedRuleCallable(const CreateRateBasedRuleRequestT& request) const { return SubmitCallable(&WAFClient::CreateRateBasedRule, request); } /** * An Async wrapper for CreateRateBasedRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRateBasedRuleAsync(const CreateRateBasedRuleRequestT& request, const CreateRateBasedRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateRateBasedRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * RegexMatchSet. You then use UpdateRegexMatchSet to identify the * part of a web request that you want AWS WAF to inspect, such as the values of * the User-Agent header or the query string. For example, you can * create a RegexMatchSet that contains a RegexMatchTuple * that looks for any requests with User-Agent headers that match a * RegexPatternSet with pattern B[a@]dB[o0]t. You can * then configure AWS WAF to reject those requests.

To create and configure * a RegexMatchSet, perform the following steps:

  1. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a CreateRegexMatchSet * request.

  2. Submit a CreateRegexMatchSet * request.

  3. Use GetChangeToken to get the change * token that you provide in the ChangeToken parameter of an * UpdateRegexMatchSet request.

  4. Submit an * UpdateRegexMatchSet request to specify the part of the request that you * want AWS WAF to inspect (for example, the header or the URI) and the value, * using a RegexPatternSet, that you want AWS WAF to watch for.

    *

For more information about how to use the AWS WAF API to allow or * block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRegexMatchSetOutcome CreateRegexMatchSet(const Model::CreateRegexMatchSetRequest& request) const; /** * A Callable wrapper for CreateRegexMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRegexMatchSetOutcomeCallable CreateRegexMatchSetCallable(const CreateRegexMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateRegexMatchSet, request); } /** * An Async wrapper for CreateRegexMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRegexMatchSetAsync(const CreateRegexMatchSetRequestT& request, const CreateRegexMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateRegexMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * RegexPatternSet. You then use UpdateRegexPatternSet to * specify the regular expression (regex) pattern that you want AWS WAF to search * for, such as B[a@]dB[o0]t. You can then configure AWS WAF to reject * those requests.

To create and configure a RegexPatternSet, * perform the following steps:

  1. Use GetChangeToken to get * the change token that you provide in the ChangeToken parameter of a * CreateRegexPatternSet request.

  2. Submit a * CreateRegexPatternSet request.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateRegexPatternSet * request.

  4. Submit an UpdateRegexPatternSet request to * specify the string that you want AWS WAF to watch for.

For * more information about how to use the AWS WAF API to allow or block HTTP * requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRegexPatternSetOutcome CreateRegexPatternSet(const Model::CreateRegexPatternSetRequest& request) const; /** * A Callable wrapper for CreateRegexPatternSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRegexPatternSetOutcomeCallable CreateRegexPatternSetCallable(const CreateRegexPatternSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateRegexPatternSet, request); } /** * An Async wrapper for CreateRegexPatternSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRegexPatternSetAsync(const CreateRegexPatternSetRequestT& request, const CreateRegexPatternSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateRegexPatternSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * Rule, which contains the IPSet objects, * ByteMatchSet objects, and other predicates that identify the * requests that you want to block. If you add more than one predicate to a * Rule, a request must match all of the specifications to be allowed * or blocked. For example, suppose that you add the following to a * Rule:

  • An IPSet that matches the IP * address 192.0.2.44/32

  • A * ByteMatchSet that matches BadBot in the * User-Agent header

You then add the * Rule to a WebACL and specify that you want to blocks * requests that satisfy the Rule. For a request to be blocked, it * must come from the IP address 192.0.2.44 and the User-Agent * header in the request must contain the value BadBot.

To * create and configure a Rule, perform the following steps:

    *

  1. Create and update the predicates that you want to include in the * Rule. For more information, see CreateByteMatchSet, * CreateIPSet, and CreateSqlInjectionMatchSet.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a CreateRule request.

    *

  3. Submit a CreateRule request.

  4. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateRule request.

    5. *

  5. Submit an UpdateRule request to specify the predicates that * you want to include in the Rule.

  6. Create and * update a WebACL that contains the Rule. For more * information, see CreateWebACL.

For more information * about how to use the AWS WAF API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS API * Reference

*/ virtual Model::CreateRuleOutcome CreateRule(const Model::CreateRuleRequest& request) const; /** * A Callable wrapper for CreateRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRuleOutcomeCallable CreateRuleCallable(const CreateRuleRequestT& request) const { return SubmitCallable(&WAFClient::CreateRule, request); } /** * An Async wrapper for CreateRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRuleAsync(const CreateRuleRequestT& request, const CreateRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * RuleGroup. A rule group is a collection of predefined rules that * you add to a web ACL. You use UpdateRuleGroup to add rules to the rule * group.

Rule groups are subject to the following limits:

  • *

    Three rule groups per account. You can request an increase to this limit by * contacting customer support.

  • One rule group per web ACL.

    *

  • Ten rules per rule group.

For more information * about how to use the AWS WAF API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateRuleGroupOutcome CreateRuleGroup(const Model::CreateRuleGroupRequest& request) const; /** * A Callable wrapper for CreateRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRuleGroupOutcomeCallable CreateRuleGroupCallable(const CreateRuleGroupRequestT& request) const { return SubmitCallable(&WAFClient::CreateRuleGroup, request); } /** * An Async wrapper for CreateRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRuleGroupAsync(const CreateRuleGroupRequestT& request, const CreateRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateRuleGroup, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * SizeConstraintSet. You then use UpdateSizeConstraintSet to * identify the part of a web request that you want AWS WAF to check for length, * such as the length of the User-Agent header or the length of the * query string. For example, you can create a SizeConstraintSet that * matches any requests that have a query string that is longer than 100 bytes. You * can then configure AWS WAF to reject those requests.

To create and * configure a SizeConstraintSet, perform the following steps:

*

  1. Use GetChangeToken to get the change token that you provide * in the ChangeToken parameter of a * CreateSizeConstraintSet request.

  2. Submit a * CreateSizeConstraintSet request.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateSizeConstraintSet * request.

  4. Submit an UpdateSizeConstraintSet request to * specify the part of the request that you want AWS WAF to inspect (for example, * the header or the URI) and the value that you want AWS WAF to watch for.

    *

For more information about how to use the AWS WAF API to allow or * block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSizeConstraintSetOutcome CreateSizeConstraintSet(const Model::CreateSizeConstraintSetRequest& request) const; /** * A Callable wrapper for CreateSizeConstraintSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSizeConstraintSetOutcomeCallable CreateSizeConstraintSetCallable(const CreateSizeConstraintSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateSizeConstraintSet, request); } /** * An Async wrapper for CreateSizeConstraintSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSizeConstraintSetAsync(const CreateSizeConstraintSetRequestT& request, const CreateSizeConstraintSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateSizeConstraintSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * SqlInjectionMatchSet, which you use to allow, block, or count requests * that contain snippets of SQL code in a specified part of web requests. AWS WAF * searches for character sequences that are likely to be malicious strings.

*

To create and configure a SqlInjectionMatchSet, perform the * following steps:

  1. Use GetChangeToken to get the change * token that you provide in the ChangeToken parameter of a * CreateSqlInjectionMatchSet request.

  2. Submit a * CreateSqlInjectionMatchSet request.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateSqlInjectionMatchSet * request.

  4. Submit an UpdateSqlInjectionMatchSet request * to specify the parts of web requests in which you want to allow, block, or count * malicious SQL code.

For more information about how to use the * AWS WAF API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateSqlInjectionMatchSetOutcome CreateSqlInjectionMatchSet(const Model::CreateSqlInjectionMatchSetRequest& request) const; /** * A Callable wrapper for CreateSqlInjectionMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateSqlInjectionMatchSetOutcomeCallable CreateSqlInjectionMatchSetCallable(const CreateSqlInjectionMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateSqlInjectionMatchSet, request); } /** * An Async wrapper for CreateSqlInjectionMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateSqlInjectionMatchSetAsync(const CreateSqlInjectionMatchSetRequestT& request, const CreateSqlInjectionMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateSqlInjectionMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates a * WebACL, which contains the Rules that identify the * CloudFront web requests that you want to allow, block, or count. AWS WAF * evaluates Rules in order based on the value of * Priority for each Rule.

You also specify a * default action, either ALLOW or BLOCK. If a web * request doesn't match any of the Rules in a WebACL, * AWS WAF responds to the request with the default action.

To create and * configure a WebACL, perform the following steps:

  1. *

    Create and update the ByteMatchSet objects and other predicates * that you want to include in Rules. For more information, see * CreateByteMatchSet, UpdateByteMatchSet, CreateIPSet, * UpdateIPSet, CreateSqlInjectionMatchSet, and * UpdateSqlInjectionMatchSet.

  2. Create and update the * Rules that you want to include in the WebACL. For more * information, see CreateRule and UpdateRule.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a CreateWebACL request.

    *

  4. Submit a CreateWebACL request.

  5. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateWebACL request.

    6. *

  6. Submit an UpdateWebACL request to specify the Rules * that you want to include in the WebACL, to specify the default * action, and to associate the WebACL with a CloudFront * distribution.

For more information about how to use the AWS * WAF API, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateWebACLOutcome CreateWebACL(const Model::CreateWebACLRequest& request) const; /** * A Callable wrapper for CreateWebACL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWebACLOutcomeCallable CreateWebACLCallable(const CreateWebACLRequestT& request) const { return SubmitCallable(&WAFClient::CreateWebACL, request); } /** * An Async wrapper for CreateWebACL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWebACLAsync(const CreateWebACLRequestT& request, const CreateWebACLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateWebACL, request, handler, context); } /** *

Creates an AWS CloudFormation WAFV2 template for the specified web ACL in the * specified Amazon S3 bucket. Then, in CloudFormation, you create a stack from the * template, to create the web ACL and its resources in AWS WAFV2. Use this to * migrate your AWS WAF Classic web ACL to the latest version of AWS WAF.

*

This is part of a larger migration procedure for web ACLs from AWS WAF * Classic to the latest version of AWS WAF. For the full procedure, including * caveats and manual steps to complete the migration and switch over to the new * web ACL, see Migrating * your AWS WAF Classic resources to AWS WAF in the AWS * WAF Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateWebACLMigrationStackOutcome CreateWebACLMigrationStack(const Model::CreateWebACLMigrationStackRequest& request) const; /** * A Callable wrapper for CreateWebACLMigrationStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWebACLMigrationStackOutcomeCallable CreateWebACLMigrationStackCallable(const CreateWebACLMigrationStackRequestT& request) const { return SubmitCallable(&WAFClient::CreateWebACLMigrationStack, request); } /** * An Async wrapper for CreateWebACLMigrationStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWebACLMigrationStackAsync(const CreateWebACLMigrationStackRequestT& request, const CreateWebACLMigrationStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateWebACLMigrationStack, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Creates an * XssMatchSet, which you use to allow, block, or count requests that * contain cross-site scripting attacks in the specified part of web requests. AWS * WAF searches for character sequences that are likely to be malicious * strings.

To create and configure an XssMatchSet, perform the * following steps:

  1. Use GetChangeToken to get the change * token that you provide in the ChangeToken parameter of a * CreateXssMatchSet request.

  2. Submit a * CreateXssMatchSet request.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateXssMatchSet request.

    *

  4. Submit an UpdateXssMatchSet request to specify the parts of * web requests in which you want to allow, block, or count cross-site scripting * attacks.

For more information about how to use the AWS WAF * API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateXssMatchSetOutcome CreateXssMatchSet(const Model::CreateXssMatchSetRequest& request) const; /** * A Callable wrapper for CreateXssMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateXssMatchSetOutcomeCallable CreateXssMatchSetCallable(const CreateXssMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::CreateXssMatchSet, request); } /** * An Async wrapper for CreateXssMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateXssMatchSetAsync(const CreateXssMatchSetRequestT& request, const CreateXssMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::CreateXssMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * ByteMatchSet. You can't delete a ByteMatchSet if it's still * used in any Rules or if it still includes any ByteMatchTuple * objects (any filters).

If you just want to remove a * ByteMatchSet from a Rule, use UpdateRule.

*

To permanently delete a ByteMatchSet, perform the following * steps:

  1. Update the ByteMatchSet to remove filters, * if any. For more information, see UpdateByteMatchSet.

  2. *

    Use GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a DeleteByteMatchSet * request.

  3. Submit a DeleteByteMatchSet request.

    *

See Also:

AWS * API Reference

*/ virtual Model::DeleteByteMatchSetOutcome DeleteByteMatchSet(const Model::DeleteByteMatchSetRequest& request) const; /** * A Callable wrapper for DeleteByteMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteByteMatchSetOutcomeCallable DeleteByteMatchSetCallable(const DeleteByteMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteByteMatchSet, request); } /** * An Async wrapper for DeleteByteMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteByteMatchSetAsync(const DeleteByteMatchSetRequestT& request, const DeleteByteMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteByteMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * GeoMatchSet. You can't delete a GeoMatchSet if it's still * used in any Rules or if it still includes any countries.

If * you just want to remove a GeoMatchSet from a Rule, use * UpdateRule.

To permanently delete a GeoMatchSet from * AWS WAF, perform the following steps:

  1. Update the * GeoMatchSet to remove any countries. For more information, see * UpdateGeoMatchSet.

  2. Use GetChangeToken to get the * change token that you provide in the ChangeToken parameter of a * DeleteGeoMatchSet request.

  3. Submit a * DeleteGeoMatchSet request.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteGeoMatchSetOutcome DeleteGeoMatchSet(const Model::DeleteGeoMatchSetRequest& request) const; /** * A Callable wrapper for DeleteGeoMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteGeoMatchSetOutcomeCallable DeleteGeoMatchSetCallable(const DeleteGeoMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteGeoMatchSet, request); } /** * An Async wrapper for DeleteGeoMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteGeoMatchSetAsync(const DeleteGeoMatchSetRequestT& request, const DeleteGeoMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteGeoMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes an * IPSet. You can't delete an IPSet if it's still used in any * Rules or if it still includes any IP addresses.

If you just * want to remove an IPSet from a Rule, use * UpdateRule.

To permanently delete an IPSet from AWS * WAF, perform the following steps:

  1. Update the IPSet * to remove IP address ranges, if any. For more information, see * UpdateIPSet.

  2. Use GetChangeToken to get the * change token that you provide in the ChangeToken parameter of a * DeleteIPSet request.

  3. Submit a * DeleteIPSet request.

See Also:

AWS API * Reference

*/ virtual Model::DeleteIPSetOutcome DeleteIPSet(const Model::DeleteIPSetRequest& request) const; /** * A Callable wrapper for DeleteIPSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIPSetOutcomeCallable DeleteIPSetCallable(const DeleteIPSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteIPSet, request); } /** * An Async wrapper for DeleteIPSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIPSetAsync(const DeleteIPSetRequestT& request, const DeleteIPSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteIPSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes the * LoggingConfiguration from the specified web ACL.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteLoggingConfigurationOutcome DeleteLoggingConfiguration(const Model::DeleteLoggingConfigurationRequest& request) const; /** * A Callable wrapper for DeleteLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteLoggingConfigurationOutcomeCallable DeleteLoggingConfigurationCallable(const DeleteLoggingConfigurationRequestT& request) const { return SubmitCallable(&WAFClient::DeleteLoggingConfiguration, request); } /** * An Async wrapper for DeleteLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteLoggingConfigurationAsync(const DeleteLoggingConfigurationRequestT& request, const DeleteLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteLoggingConfiguration, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes an * IAM policy from the specified RuleGroup.

The user making the request must * be the owner of the RuleGroup.

See Also:

AWS * API Reference

*/ virtual Model::DeletePermissionPolicyOutcome DeletePermissionPolicy(const Model::DeletePermissionPolicyRequest& request) const; /** * A Callable wrapper for DeletePermissionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePermissionPolicyOutcomeCallable DeletePermissionPolicyCallable(const DeletePermissionPolicyRequestT& request) const { return SubmitCallable(&WAFClient::DeletePermissionPolicy, request); } /** * An Async wrapper for DeletePermissionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePermissionPolicyAsync(const DeletePermissionPolicyRequestT& request, const DeletePermissionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeletePermissionPolicy, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * RateBasedRule. You can't delete a rule if it's still used in any * WebACL objects or if it still includes any predicates, such as * ByteMatchSet objects.

If you just want to remove a rule from * a WebACL, use UpdateWebACL.

To permanently delete a * RateBasedRule from AWS WAF, perform the following steps:

    *

  1. Update the RateBasedRule to remove predicates, if any. For * more information, see UpdateRateBasedRule.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a DeleteRateBasedRule * request.

  3. Submit a DeleteRateBasedRule * request.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRateBasedRuleOutcome DeleteRateBasedRule(const Model::DeleteRateBasedRuleRequest& request) const; /** * A Callable wrapper for DeleteRateBasedRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRateBasedRuleOutcomeCallable DeleteRateBasedRuleCallable(const DeleteRateBasedRuleRequestT& request) const { return SubmitCallable(&WAFClient::DeleteRateBasedRule, request); } /** * An Async wrapper for DeleteRateBasedRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRateBasedRuleAsync(const DeleteRateBasedRuleRequestT& request, const DeleteRateBasedRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteRateBasedRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * RegexMatchSet. You can't delete a RegexMatchSet if it's * still used in any Rules or if it still includes any * RegexMatchTuples objects (any filters).

If you just want to * remove a RegexMatchSet from a Rule, use * UpdateRule.

To permanently delete a RegexMatchSet, * perform the following steps:

  1. Update the * RegexMatchSet to remove filters, if any. For more information, see * UpdateRegexMatchSet.

  2. Use GetChangeToken to get * the change token that you provide in the ChangeToken parameter of a * DeleteRegexMatchSet request.

  3. Submit a * DeleteRegexMatchSet request.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteRegexMatchSetOutcome DeleteRegexMatchSet(const Model::DeleteRegexMatchSetRequest& request) const; /** * A Callable wrapper for DeleteRegexMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRegexMatchSetOutcomeCallable DeleteRegexMatchSetCallable(const DeleteRegexMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteRegexMatchSet, request); } /** * An Async wrapper for DeleteRegexMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRegexMatchSetAsync(const DeleteRegexMatchSetRequestT& request, const DeleteRegexMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteRegexMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * RegexPatternSet. You can't delete a RegexPatternSet if it's * still used in any RegexMatchSet or if the * RegexPatternSet is not empty.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRegexPatternSetOutcome DeleteRegexPatternSet(const Model::DeleteRegexPatternSetRequest& request) const; /** * A Callable wrapper for DeleteRegexPatternSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRegexPatternSetOutcomeCallable DeleteRegexPatternSetCallable(const DeleteRegexPatternSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteRegexPatternSet, request); } /** * An Async wrapper for DeleteRegexPatternSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRegexPatternSetAsync(const DeleteRegexPatternSetRequestT& request, const DeleteRegexPatternSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteRegexPatternSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * Rule. You can't delete a Rule if it's still used in any * WebACL objects or if it still includes any predicates, such as * ByteMatchSet objects.

If you just want to remove a * Rule from a WebACL, use UpdateWebACL.

To * permanently delete a Rule from AWS WAF, perform the following * steps:

  1. Update the Rule to remove predicates, if * any. For more information, see UpdateRule.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a DeleteRule request.

    *

  3. Submit a DeleteRule request.

    4. *

See Also:

AWS API * Reference

*/ virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const; /** * A Callable wrapper for DeleteRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const { return SubmitCallable(&WAFClient::DeleteRule, request); } /** * An Async wrapper for DeleteRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * RuleGroup. You can't delete a RuleGroup if it's still used * in any WebACL objects or if it still includes any rules.

If * you just want to remove a RuleGroup from a WebACL, use * UpdateWebACL.

To permanently delete a RuleGroup from * AWS WAF, perform the following steps:

  1. Update the * RuleGroup to remove rules, if any. For more information, see * UpdateRuleGroup.

  2. Use GetChangeToken to get the * change token that you provide in the ChangeToken parameter of a * DeleteRuleGroup request.

  3. Submit a * DeleteRuleGroup request.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRuleGroupOutcome DeleteRuleGroup(const Model::DeleteRuleGroupRequest& request) const; /** * A Callable wrapper for DeleteRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRuleGroupOutcomeCallable DeleteRuleGroupCallable(const DeleteRuleGroupRequestT& request) const { return SubmitCallable(&WAFClient::DeleteRuleGroup, request); } /** * An Async wrapper for DeleteRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRuleGroupAsync(const DeleteRuleGroupRequestT& request, const DeleteRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteRuleGroup, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * SizeConstraintSet. You can't delete a SizeConstraintSet if * it's still used in any Rules or if it still includes any * SizeConstraint objects (any filters).

If you just want to remove a * SizeConstraintSet from a Rule, use * UpdateRule.

To permanently delete a * SizeConstraintSet, perform the following steps:

  1. *

    Update the SizeConstraintSet to remove filters, if any. For more * information, see UpdateSizeConstraintSet.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a DeleteSizeConstraintSet * request.

  3. Submit a DeleteSizeConstraintSet * request.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSizeConstraintSetOutcome DeleteSizeConstraintSet(const Model::DeleteSizeConstraintSetRequest& request) const; /** * A Callable wrapper for DeleteSizeConstraintSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSizeConstraintSetOutcomeCallable DeleteSizeConstraintSetCallable(const DeleteSizeConstraintSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteSizeConstraintSet, request); } /** * An Async wrapper for DeleteSizeConstraintSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSizeConstraintSetAsync(const DeleteSizeConstraintSetRequestT& request, const DeleteSizeConstraintSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteSizeConstraintSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * SqlInjectionMatchSet. You can't delete a * SqlInjectionMatchSet if it's still used in any Rules * or if it still contains any SqlInjectionMatchTuple objects.

If you * just want to remove a SqlInjectionMatchSet from a * Rule, use UpdateRule.

To permanently delete a * SqlInjectionMatchSet from AWS WAF, perform the following steps:

*

  1. Update the SqlInjectionMatchSet to remove filters, if * any. For more information, see UpdateSqlInjectionMatchSet.

  2. *

    Use GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a DeleteSqlInjectionMatchSet * request.

  3. Submit a DeleteSqlInjectionMatchSet * request.

See Also:

AWS * API Reference

*/ virtual Model::DeleteSqlInjectionMatchSetOutcome DeleteSqlInjectionMatchSet(const Model::DeleteSqlInjectionMatchSetRequest& request) const; /** * A Callable wrapper for DeleteSqlInjectionMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteSqlInjectionMatchSetOutcomeCallable DeleteSqlInjectionMatchSetCallable(const DeleteSqlInjectionMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteSqlInjectionMatchSet, request); } /** * An Async wrapper for DeleteSqlInjectionMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteSqlInjectionMatchSetAsync(const DeleteSqlInjectionMatchSetRequestT& request, const DeleteSqlInjectionMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteSqlInjectionMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes a * WebACL. You can't delete a WebACL if it still contains any * Rules.

To delete a WebACL, perform the * following steps:

  1. Update the WebACL to remove * Rules, if any. For more information, see UpdateWebACL.

    *

  2. Use GetChangeToken to get the change token that you provide * in the ChangeToken parameter of a DeleteWebACL * request.

  3. Submit a DeleteWebACL request.

    4. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteWebACLOutcome DeleteWebACL(const Model::DeleteWebACLRequest& request) const; /** * A Callable wrapper for DeleteWebACL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteWebACLOutcomeCallable DeleteWebACLCallable(const DeleteWebACLRequestT& request) const { return SubmitCallable(&WAFClient::DeleteWebACL, request); } /** * An Async wrapper for DeleteWebACL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteWebACLAsync(const DeleteWebACLRequestT& request, const DeleteWebACLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteWebACL, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Permanently deletes an * XssMatchSet. You can't delete an XssMatchSet if it's still * used in any Rules or if it still contains any XssMatchTuple * objects.

If you just want to remove an XssMatchSet from a * Rule, use UpdateRule.

To permanently delete an * XssMatchSet from AWS WAF, perform the following steps:

    *

  1. Update the XssMatchSet to remove filters, if any. For more * information, see UpdateXssMatchSet.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of a DeleteXssMatchSet * request.

  3. Submit a DeleteXssMatchSet request.

    *

See Also:

AWS * API Reference

*/ virtual Model::DeleteXssMatchSetOutcome DeleteXssMatchSet(const Model::DeleteXssMatchSetRequest& request) const; /** * A Callable wrapper for DeleteXssMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteXssMatchSetOutcomeCallable DeleteXssMatchSetCallable(const DeleteXssMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::DeleteXssMatchSet, request); } /** * An Async wrapper for DeleteXssMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteXssMatchSetAsync(const DeleteXssMatchSetRequestT& request, const DeleteXssMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::DeleteXssMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * ByteMatchSet specified by ByteMatchSetId.

See * Also:

AWS * API Reference

*/ virtual Model::GetByteMatchSetOutcome GetByteMatchSet(const Model::GetByteMatchSetRequest& request) const; /** * A Callable wrapper for GetByteMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetByteMatchSetOutcomeCallable GetByteMatchSetCallable(const GetByteMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::GetByteMatchSet, request); } /** * An Async wrapper for GetByteMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetByteMatchSetAsync(const GetByteMatchSetRequestT& request, const GetByteMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetByteMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

When you want to create, * update, or delete AWS WAF objects, get a change token and include the change * token in the create, update, or delete request. Change tokens ensure that your * application doesn't submit conflicting requests to AWS WAF.

Each create, * update, or delete request must use a unique change token. If your application * submits a GetChangeToken request and then submits a second * GetChangeToken request before submitting a create, update, or * delete request, the second GetChangeToken request returns the same * value as the first GetChangeToken request.

When you use a * change token in a create, update, or delete request, the status of the change * token changes to PENDING, which indicates that AWS WAF is * propagating the change to all AWS WAF servers. Use * GetChangeTokenStatus to determine the status of your change * token.

See Also:

AWS * API Reference

*/ virtual Model::GetChangeTokenOutcome GetChangeToken(const Model::GetChangeTokenRequest& request) const; /** * A Callable wrapper for GetChangeToken that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetChangeTokenOutcomeCallable GetChangeTokenCallable(const GetChangeTokenRequestT& request) const { return SubmitCallable(&WAFClient::GetChangeToken, request); } /** * An Async wrapper for GetChangeToken that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetChangeTokenAsync(const GetChangeTokenRequestT& request, const GetChangeTokenResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetChangeToken, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the status of a * ChangeToken that you got by calling GetChangeToken. * ChangeTokenStatus is one of the following values:

  • * PROVISIONED: You requested the change token by calling * GetChangeToken, but you haven't used it yet in a call to create, * update, or delete an AWS WAF object.

  • PENDING: * AWS WAF is propagating the create, update, or delete request to all AWS WAF * servers.

  • INSYNC: Propagation is complete.

    *

See Also:

AWS * API Reference

*/ virtual Model::GetChangeTokenStatusOutcome GetChangeTokenStatus(const Model::GetChangeTokenStatusRequest& request) const; /** * A Callable wrapper for GetChangeTokenStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetChangeTokenStatusOutcomeCallable GetChangeTokenStatusCallable(const GetChangeTokenStatusRequestT& request) const { return SubmitCallable(&WAFClient::GetChangeTokenStatus, request); } /** * An Async wrapper for GetChangeTokenStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetChangeTokenStatusAsync(const GetChangeTokenStatusRequestT& request, const GetChangeTokenStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetChangeTokenStatus, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * GeoMatchSet that is specified by * GeoMatchSetId.

See Also:

AWS * API Reference

*/ virtual Model::GetGeoMatchSetOutcome GetGeoMatchSet(const Model::GetGeoMatchSetRequest& request) const; /** * A Callable wrapper for GetGeoMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetGeoMatchSetOutcomeCallable GetGeoMatchSetCallable(const GetGeoMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::GetGeoMatchSet, request); } /** * An Async wrapper for GetGeoMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetGeoMatchSetAsync(const GetGeoMatchSetRequestT& request, const GetGeoMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetGeoMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the IPSet * that is specified by IPSetId.

See Also:

AWS API * Reference

*/ virtual Model::GetIPSetOutcome GetIPSet(const Model::GetIPSetRequest& request) const; /** * A Callable wrapper for GetIPSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetIPSetOutcomeCallable GetIPSetCallable(const GetIPSetRequestT& request) const { return SubmitCallable(&WAFClient::GetIPSet, request); } /** * An Async wrapper for GetIPSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetIPSetAsync(const GetIPSetRequestT& request, const GetIPSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetIPSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * LoggingConfiguration for the specified web ACL.

See Also:

* AWS * API Reference

*/ virtual Model::GetLoggingConfigurationOutcome GetLoggingConfiguration(const Model::GetLoggingConfigurationRequest& request) const; /** * A Callable wrapper for GetLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetLoggingConfigurationOutcomeCallable GetLoggingConfigurationCallable(const GetLoggingConfigurationRequestT& request) const { return SubmitCallable(&WAFClient::GetLoggingConfiguration, request); } /** * An Async wrapper for GetLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetLoggingConfigurationAsync(const GetLoggingConfigurationRequestT& request, const GetLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetLoggingConfiguration, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the IAM policy * attached to the RuleGroup.

See Also:

AWS * API Reference

*/ virtual Model::GetPermissionPolicyOutcome GetPermissionPolicy(const Model::GetPermissionPolicyRequest& request) const; /** * A Callable wrapper for GetPermissionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPermissionPolicyOutcomeCallable GetPermissionPolicyCallable(const GetPermissionPolicyRequestT& request) const { return SubmitCallable(&WAFClient::GetPermissionPolicy, request); } /** * An Async wrapper for GetPermissionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPermissionPolicyAsync(const GetPermissionPolicyRequestT& request, const GetPermissionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetPermissionPolicy, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * RateBasedRule that is specified by the RuleId that you * included in the GetRateBasedRule request.

See Also:

* AWS * API Reference

*/ virtual Model::GetRateBasedRuleOutcome GetRateBasedRule(const Model::GetRateBasedRuleRequest& request) const; /** * A Callable wrapper for GetRateBasedRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRateBasedRuleOutcomeCallable GetRateBasedRuleCallable(const GetRateBasedRuleRequestT& request) const { return SubmitCallable(&WAFClient::GetRateBasedRule, request); } /** * An Async wrapper for GetRateBasedRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRateBasedRuleAsync(const GetRateBasedRuleRequestT& request, const GetRateBasedRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetRateBasedRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of IP * addresses currently being blocked by the RateBasedRule that is specified * by the RuleId. The maximum number of managed keys that will be * blocked is 10,000. If more than 10,000 addresses exceed the rate limit, the * 10,000 addresses with the highest rates will be blocked.

See * Also:

AWS * API Reference

*/ virtual Model::GetRateBasedRuleManagedKeysOutcome GetRateBasedRuleManagedKeys(const Model::GetRateBasedRuleManagedKeysRequest& request) const; /** * A Callable wrapper for GetRateBasedRuleManagedKeys that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRateBasedRuleManagedKeysOutcomeCallable GetRateBasedRuleManagedKeysCallable(const GetRateBasedRuleManagedKeysRequestT& request) const { return SubmitCallable(&WAFClient::GetRateBasedRuleManagedKeys, request); } /** * An Async wrapper for GetRateBasedRuleManagedKeys that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRateBasedRuleManagedKeysAsync(const GetRateBasedRuleManagedKeysRequestT& request, const GetRateBasedRuleManagedKeysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetRateBasedRuleManagedKeys, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * RegexMatchSet specified by RegexMatchSetId.

See * Also:

AWS * API Reference

*/ virtual Model::GetRegexMatchSetOutcome GetRegexMatchSet(const Model::GetRegexMatchSetRequest& request) const; /** * A Callable wrapper for GetRegexMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRegexMatchSetOutcomeCallable GetRegexMatchSetCallable(const GetRegexMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::GetRegexMatchSet, request); } /** * An Async wrapper for GetRegexMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRegexMatchSetAsync(const GetRegexMatchSetRequestT& request, const GetRegexMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetRegexMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * RegexPatternSet specified by * RegexPatternSetId.

See Also:

AWS * API Reference

*/ virtual Model::GetRegexPatternSetOutcome GetRegexPatternSet(const Model::GetRegexPatternSetRequest& request) const; /** * A Callable wrapper for GetRegexPatternSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRegexPatternSetOutcomeCallable GetRegexPatternSetCallable(const GetRegexPatternSetRequestT& request) const { return SubmitCallable(&WAFClient::GetRegexPatternSet, request); } /** * An Async wrapper for GetRegexPatternSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRegexPatternSetAsync(const GetRegexPatternSetRequestT& request, const GetRegexPatternSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetRegexPatternSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the Rule * that is specified by the RuleId that you included in the * GetRule request.

See Also:

AWS API * Reference

*/ virtual Model::GetRuleOutcome GetRule(const Model::GetRuleRequest& request) const; /** * A Callable wrapper for GetRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRuleOutcomeCallable GetRuleCallable(const GetRuleRequestT& request) const { return SubmitCallable(&WAFClient::GetRule, request); } /** * An Async wrapper for GetRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRuleAsync(const GetRuleRequestT& request, const GetRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * RuleGroup that is specified by the RuleGroupId that you * included in the GetRuleGroup request.

To view the rules in a * rule group, use ListActivatedRulesInRuleGroup.

See Also:

* AWS * API Reference

*/ virtual Model::GetRuleGroupOutcome GetRuleGroup(const Model::GetRuleGroupRequest& request) const; /** * A Callable wrapper for GetRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRuleGroupOutcomeCallable GetRuleGroupCallable(const GetRuleGroupRequestT& request) const { return SubmitCallable(&WAFClient::GetRuleGroup, request); } /** * An Async wrapper for GetRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRuleGroupAsync(const GetRuleGroupRequestT& request, const GetRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetRuleGroup, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Gets detailed information * about a specified number of requests--a sample--that AWS WAF randomly selects * from among the first 5,000 requests that your AWS resource received during a * time range that you choose. You can specify a sample size of up to 500 requests, * and you can specify any time range in the previous three hours.

* GetSampledRequests returns a time range, which is usually the time * range that you specified. However, if your resource (such as a CloudFront * distribution) received 5,000 requests before the specified time range elapsed, * GetSampledRequests returns an updated time range. This new time * range indicates the actual period during which AWS WAF selected the requests in * the sample.

See Also:

AWS * API Reference

*/ virtual Model::GetSampledRequestsOutcome GetSampledRequests(const Model::GetSampledRequestsRequest& request) const; /** * A Callable wrapper for GetSampledRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSampledRequestsOutcomeCallable GetSampledRequestsCallable(const GetSampledRequestsRequestT& request) const { return SubmitCallable(&WAFClient::GetSampledRequests, request); } /** * An Async wrapper for GetSampledRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSampledRequestsAsync(const GetSampledRequestsRequestT& request, const GetSampledRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetSampledRequests, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * SizeConstraintSet specified by * SizeConstraintSetId.

See Also:

AWS * API Reference

*/ virtual Model::GetSizeConstraintSetOutcome GetSizeConstraintSet(const Model::GetSizeConstraintSetRequest& request) const; /** * A Callable wrapper for GetSizeConstraintSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSizeConstraintSetOutcomeCallable GetSizeConstraintSetCallable(const GetSizeConstraintSetRequestT& request) const { return SubmitCallable(&WAFClient::GetSizeConstraintSet, request); } /** * An Async wrapper for GetSizeConstraintSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSizeConstraintSetAsync(const GetSizeConstraintSetRequestT& request, const GetSizeConstraintSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetSizeConstraintSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * SqlInjectionMatchSet that is specified by * SqlInjectionMatchSetId.

See Also:

AWS * API Reference

*/ virtual Model::GetSqlInjectionMatchSetOutcome GetSqlInjectionMatchSet(const Model::GetSqlInjectionMatchSetRequest& request) const; /** * A Callable wrapper for GetSqlInjectionMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetSqlInjectionMatchSetOutcomeCallable GetSqlInjectionMatchSetCallable(const GetSqlInjectionMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::GetSqlInjectionMatchSet, request); } /** * An Async wrapper for GetSqlInjectionMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetSqlInjectionMatchSetAsync(const GetSqlInjectionMatchSetRequestT& request, const GetSqlInjectionMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetSqlInjectionMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the WebACL * that is specified by WebACLId.

See Also:

AWS API * Reference

*/ virtual Model::GetWebACLOutcome GetWebACL(const Model::GetWebACLRequest& request) const; /** * A Callable wrapper for GetWebACL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetWebACLOutcomeCallable GetWebACLCallable(const GetWebACLRequestT& request) const { return SubmitCallable(&WAFClient::GetWebACL, request); } /** * An Async wrapper for GetWebACL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetWebACLAsync(const GetWebACLRequestT& request, const GetWebACLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetWebACL, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns the * XssMatchSet that is specified by * XssMatchSetId.

See Also:

AWS * API Reference

*/ virtual Model::GetXssMatchSetOutcome GetXssMatchSet(const Model::GetXssMatchSetRequest& request) const; /** * A Callable wrapper for GetXssMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetXssMatchSetOutcomeCallable GetXssMatchSetCallable(const GetXssMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::GetXssMatchSet, request); } /** * An Async wrapper for GetXssMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetXssMatchSetAsync(const GetXssMatchSetRequestT& request, const GetXssMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::GetXssMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * ActivatedRule objects.

See Also:

AWS * API Reference

*/ virtual Model::ListActivatedRulesInRuleGroupOutcome ListActivatedRulesInRuleGroup(const Model::ListActivatedRulesInRuleGroupRequest& request) const; /** * A Callable wrapper for ListActivatedRulesInRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListActivatedRulesInRuleGroupOutcomeCallable ListActivatedRulesInRuleGroupCallable(const ListActivatedRulesInRuleGroupRequestT& request) const { return SubmitCallable(&WAFClient::ListActivatedRulesInRuleGroup, request); } /** * An Async wrapper for ListActivatedRulesInRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListActivatedRulesInRuleGroupAsync(const ListActivatedRulesInRuleGroupRequestT& request, const ListActivatedRulesInRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListActivatedRulesInRuleGroup, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * ByteMatchSetSummary objects.

See Also:

AWS * API Reference

*/ virtual Model::ListByteMatchSetsOutcome ListByteMatchSets(const Model::ListByteMatchSetsRequest& request) const; /** * A Callable wrapper for ListByteMatchSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListByteMatchSetsOutcomeCallable ListByteMatchSetsCallable(const ListByteMatchSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListByteMatchSets, request); } /** * An Async wrapper for ListByteMatchSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListByteMatchSetsAsync(const ListByteMatchSetsRequestT& request, const ListByteMatchSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListByteMatchSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * GeoMatchSetSummary objects in the response.

See Also:

AWS * API Reference

*/ virtual Model::ListGeoMatchSetsOutcome ListGeoMatchSets(const Model::ListGeoMatchSetsRequest& request) const; /** * A Callable wrapper for ListGeoMatchSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListGeoMatchSetsOutcomeCallable ListGeoMatchSetsCallable(const ListGeoMatchSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListGeoMatchSets, request); } /** * An Async wrapper for ListGeoMatchSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListGeoMatchSetsAsync(const ListGeoMatchSetsRequestT& request, const ListGeoMatchSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListGeoMatchSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * IPSetSummary objects in the response.

See Also:

AWS API * Reference

*/ virtual Model::ListIPSetsOutcome ListIPSets(const Model::ListIPSetsRequest& request) const; /** * A Callable wrapper for ListIPSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListIPSetsOutcomeCallable ListIPSetsCallable(const ListIPSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListIPSets, request); } /** * An Async wrapper for ListIPSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListIPSetsAsync(const ListIPSetsRequestT& request, const ListIPSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListIPSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * LoggingConfiguration objects.

See Also:

AWS * API Reference

*/ virtual Model::ListLoggingConfigurationsOutcome ListLoggingConfigurations(const Model::ListLoggingConfigurationsRequest& request) const; /** * A Callable wrapper for ListLoggingConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListLoggingConfigurationsOutcomeCallable ListLoggingConfigurationsCallable(const ListLoggingConfigurationsRequestT& request) const { return SubmitCallable(&WAFClient::ListLoggingConfigurations, request); } /** * An Async wrapper for ListLoggingConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListLoggingConfigurationsAsync(const ListLoggingConfigurationsRequestT& request, const ListLoggingConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListLoggingConfigurations, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * RuleSummary objects.

See Also:

AWS * API Reference

*/ virtual Model::ListRateBasedRulesOutcome ListRateBasedRules(const Model::ListRateBasedRulesRequest& request) const; /** * A Callable wrapper for ListRateBasedRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRateBasedRulesOutcomeCallable ListRateBasedRulesCallable(const ListRateBasedRulesRequestT& request) const { return SubmitCallable(&WAFClient::ListRateBasedRules, request); } /** * An Async wrapper for ListRateBasedRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRateBasedRulesAsync(const ListRateBasedRulesRequestT& request, const ListRateBasedRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListRateBasedRules, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * RegexMatchSetSummary objects.

See Also:

AWS * API Reference

*/ virtual Model::ListRegexMatchSetsOutcome ListRegexMatchSets(const Model::ListRegexMatchSetsRequest& request) const; /** * A Callable wrapper for ListRegexMatchSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRegexMatchSetsOutcomeCallable ListRegexMatchSetsCallable(const ListRegexMatchSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListRegexMatchSets, request); } /** * An Async wrapper for ListRegexMatchSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRegexMatchSetsAsync(const ListRegexMatchSetsRequestT& request, const ListRegexMatchSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListRegexMatchSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * RegexPatternSetSummary objects.

See Also:

AWS * API Reference

*/ virtual Model::ListRegexPatternSetsOutcome ListRegexPatternSets(const Model::ListRegexPatternSetsRequest& request) const; /** * A Callable wrapper for ListRegexPatternSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRegexPatternSetsOutcomeCallable ListRegexPatternSetsCallable(const ListRegexPatternSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListRegexPatternSets, request); } /** * An Async wrapper for ListRegexPatternSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRegexPatternSetsAsync(const ListRegexPatternSetsRequestT& request, const ListRegexPatternSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListRegexPatternSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * RuleGroup objects.

See Also:

AWS * API Reference

*/ virtual Model::ListRuleGroupsOutcome ListRuleGroups(const Model::ListRuleGroupsRequest& request) const; /** * A Callable wrapper for ListRuleGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRuleGroupsOutcomeCallable ListRuleGroupsCallable(const ListRuleGroupsRequestT& request) const { return SubmitCallable(&WAFClient::ListRuleGroups, request); } /** * An Async wrapper for ListRuleGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRuleGroupsAsync(const ListRuleGroupsRequestT& request, const ListRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListRuleGroups, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * RuleSummary objects.

See Also:

AWS API * Reference

*/ virtual Model::ListRulesOutcome ListRules(const Model::ListRulesRequest& request) const; /** * A Callable wrapper for ListRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRulesOutcomeCallable ListRulesCallable(const ListRulesRequestT& request) const { return SubmitCallable(&WAFClient::ListRules, request); } /** * An Async wrapper for ListRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRulesAsync(const ListRulesRequestT& request, const ListRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListRules, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * SizeConstraintSetSummary objects.

See Also:

AWS * API Reference

*/ virtual Model::ListSizeConstraintSetsOutcome ListSizeConstraintSets(const Model::ListSizeConstraintSetsRequest& request) const; /** * A Callable wrapper for ListSizeConstraintSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSizeConstraintSetsOutcomeCallable ListSizeConstraintSetsCallable(const ListSizeConstraintSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListSizeConstraintSets, request); } /** * An Async wrapper for ListSizeConstraintSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSizeConstraintSetsAsync(const ListSizeConstraintSetsRequestT& request, const ListSizeConstraintSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListSizeConstraintSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * SqlInjectionMatchSet objects.

See Also:

AWS * API Reference

*/ virtual Model::ListSqlInjectionMatchSetsOutcome ListSqlInjectionMatchSets(const Model::ListSqlInjectionMatchSetsRequest& request) const; /** * A Callable wrapper for ListSqlInjectionMatchSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSqlInjectionMatchSetsOutcomeCallable ListSqlInjectionMatchSetsCallable(const ListSqlInjectionMatchSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListSqlInjectionMatchSets, request); } /** * An Async wrapper for ListSqlInjectionMatchSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSqlInjectionMatchSetsAsync(const ListSqlInjectionMatchSetsRequestT& request, const ListSqlInjectionMatchSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListSqlInjectionMatchSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * RuleGroup objects that you are subscribed to.

See Also:

* AWS * API Reference

*/ virtual Model::ListSubscribedRuleGroupsOutcome ListSubscribedRuleGroups(const Model::ListSubscribedRuleGroupsRequest& request) const; /** * A Callable wrapper for ListSubscribedRuleGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListSubscribedRuleGroupsOutcomeCallable ListSubscribedRuleGroupsCallable(const ListSubscribedRuleGroupsRequestT& request) const { return SubmitCallable(&WAFClient::ListSubscribedRuleGroups, request); } /** * An Async wrapper for ListSubscribedRuleGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListSubscribedRuleGroupsAsync(const ListSubscribedRuleGroupsRequestT& request, const ListSubscribedRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListSubscribedRuleGroups, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Retrieves the tags * associated with the specified AWS resource. Tags are key:value pairs that you * can use to categorize and manage your resources, for purposes like billing. For * example, you might set the tag key to "customer" and the value to the customer * name or ID. You can specify one or more tags to add to each AWS resource, up to * 50 tags for a resource.

Tagging is only available through the API, SDKs, * and CLI. You can't manage or view tags through the AWS WAF Classic console. You * can tag the AWS resources that you manage through AWS WAF Classic: web ACLs, * rule groups, and rules.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&WAFClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListTagsForResource, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * WebACLSummary objects in the response.

See Also:

AWS API * Reference

*/ virtual Model::ListWebACLsOutcome ListWebACLs(const Model::ListWebACLsRequest& request) const; /** * A Callable wrapper for ListWebACLs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListWebACLsOutcomeCallable ListWebACLsCallable(const ListWebACLsRequestT& request) const { return SubmitCallable(&WAFClient::ListWebACLs, request); } /** * An Async wrapper for ListWebACLs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListWebACLsAsync(const ListWebACLsRequestT& request, const ListWebACLsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListWebACLs, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Returns an array of * XssMatchSet objects.

See Also:

AWS * API Reference

*/ virtual Model::ListXssMatchSetsOutcome ListXssMatchSets(const Model::ListXssMatchSetsRequest& request) const; /** * A Callable wrapper for ListXssMatchSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListXssMatchSetsOutcomeCallable ListXssMatchSetsCallable(const ListXssMatchSetsRequestT& request) const { return SubmitCallable(&WAFClient::ListXssMatchSets, request); } /** * An Async wrapper for ListXssMatchSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListXssMatchSetsAsync(const ListXssMatchSetsRequestT& request, const ListXssMatchSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::ListXssMatchSets, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Associates a * LoggingConfiguration with a specified web ACL.

You can access * information about all traffic that AWS WAF inspects using the following * steps:

  1. Create an Amazon Kinesis Data Firehose.

    Create * the data firehose with a PUT source and in the region that you are operating. * However, if you are capturing logs for Amazon CloudFront, always create the * firehose in US East (N. Virginia).

    Do not create the data * firehose using a Kinesis stream as your source.

    2. *

  2. Associate that firehose to your web ACL using a * PutLoggingConfiguration request.

When you * successfully enable logging using a PutLoggingConfiguration * request, AWS WAF will create a service linked role with the necessary * permissions to write logs to the Amazon Kinesis Data Firehose. For more * information, see Logging * Web ACL Traffic Information in the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::PutLoggingConfigurationOutcome PutLoggingConfiguration(const Model::PutLoggingConfigurationRequest& request) const; /** * A Callable wrapper for PutLoggingConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutLoggingConfigurationOutcomeCallable PutLoggingConfigurationCallable(const PutLoggingConfigurationRequestT& request) const { return SubmitCallable(&WAFClient::PutLoggingConfiguration, request); } /** * An Async wrapper for PutLoggingConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutLoggingConfigurationAsync(const PutLoggingConfigurationRequestT& request, const PutLoggingConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::PutLoggingConfiguration, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Attaches an IAM policy to * the specified resource. The only supported use for this action is to share a * RuleGroup across accounts.

The PutPermissionPolicy is * subject to the following restrictions:

  • You can attach only one * policy with each PutPermissionPolicy request.

  • The * policy must include an Effect, Action and * Principal.

  • Effect must specify * Allow.

  • The Action in the policy must * be waf:UpdateWebACL, waf-regional:UpdateWebACL, * waf:GetRuleGroup and waf-regional:GetRuleGroup . Any * extra or wildcard actions in the policy will be rejected.

  • The * policy cannot include a Resource parameter.

  • The * ARN in the request must be a valid WAF RuleGroup ARN and the RuleGroup must * exist in the same region.

  • The user making the request must be * the owner of the RuleGroup.

  • Your policy must be composed using * IAM Policy version 2012-10-17.

For more information, see IAM * Policies.

An example of a valid policy parameter is shown in the * Examples section below.

See Also:

AWS * API Reference

*/ virtual Model::PutPermissionPolicyOutcome PutPermissionPolicy(const Model::PutPermissionPolicyRequest& request) const; /** * A Callable wrapper for PutPermissionPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutPermissionPolicyOutcomeCallable PutPermissionPolicyCallable(const PutPermissionPolicyRequestT& request) const { return SubmitCallable(&WAFClient::PutPermissionPolicy, request); } /** * An Async wrapper for PutPermissionPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutPermissionPolicyAsync(const PutPermissionPolicyRequestT& request, const PutPermissionPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::PutPermissionPolicy, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Associates tags with the * specified AWS resource. Tags are key:value pairs that you can use to categorize * and manage your resources, for purposes like billing. For example, you might set * the tag key to "customer" and the value to the customer name or ID. You can * specify one or more tags to add to each AWS resource, up to 50 tags for a * resource.

Tagging is only available through the API, SDKs, and CLI. You * can't manage or view tags through the AWS WAF Classic console. You can use this * action to tag the AWS resources that you manage through AWS WAF Classic: web * ACLs, rule groups, and rules.

See Also:

AWS API * Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&WAFClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::TagResource, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

See Also:

* AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&WAFClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UntagResource, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * ByteMatchTuple objects (filters) in a ByteMatchSet. For each * ByteMatchTuple object, you specify the following values:

    *

  • Whether to insert or delete the object from the array. If you want to * change a ByteMatchSetUpdate object, you delete the existing object * and add a new one.

  • The part of a web request that you want AWS * WAF to inspect, such as a query string or the value of the * User-Agent header.

  • The bytes (typically a string * that corresponds with ASCII characters) that you want AWS WAF to look for. For * more information, including how you specify the values for the AWS WAF API and * the AWS CLI or SDKs, see TargetString in the ByteMatchTuple * data type.

  • Where to look, such as at the beginning or the end * of a query string.

  • Whether to perform any conversions on the * request, such as converting it to lowercase, before inspecting it for the * specified string.

For example, you can add a * ByteMatchSetUpdate object that matches web requests in which * User-Agent headers contain the string BadBot. You can * then configure AWS WAF to block those requests.

To create and configure a * ByteMatchSet, perform the following steps:

  1. Create * a ByteMatchSet. For more information, see * CreateByteMatchSet.

  2. Use GetChangeToken to get * the change token that you provide in the ChangeToken parameter of * an UpdateByteMatchSet request.

  3. Submit an * UpdateByteMatchSet request to specify the part of the request that * you want AWS WAF to inspect (for example, the header or the URI) and the value * that you want AWS WAF to watch for.

For more information * about how to use the AWS WAF API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateByteMatchSetOutcome UpdateByteMatchSet(const Model::UpdateByteMatchSetRequest& request) const; /** * A Callable wrapper for UpdateByteMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateByteMatchSetOutcomeCallable UpdateByteMatchSetCallable(const UpdateByteMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateByteMatchSet, request); } /** * An Async wrapper for UpdateByteMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateByteMatchSetAsync(const UpdateByteMatchSetRequestT& request, const UpdateByteMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateByteMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * GeoMatchConstraint objects in an GeoMatchSet. For each * GeoMatchConstraint object, you specify the following values:

*

  • Whether to insert or delete the object from the array. If you want * to change an GeoMatchConstraint object, you delete the existing * object and add a new one.

  • The Type. The only * valid value for Type is Country.

  • The * Value, which is a two character code for the country to add to the * GeoMatchConstraint object. Valid codes are listed in * GeoMatchConstraint$Value.

To create and configure an * GeoMatchSet, perform the following steps:

  1. Submit a * CreateGeoMatchSet request.

  2. Use GetChangeToken to * get the change token that you provide in the ChangeToken parameter * of an UpdateGeoMatchSet request.

  3. Submit an * UpdateGeoMatchSet request to specify the country that you want AWS * WAF to watch for.

When you update an * GeoMatchSet, you specify the country that you want to add and/or * the country that you want to delete. If you want to change a country, you delete * the existing country and add the new one.

For more information about how * to use the AWS WAF API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateGeoMatchSetOutcome UpdateGeoMatchSet(const Model::UpdateGeoMatchSetRequest& request) const; /** * A Callable wrapper for UpdateGeoMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateGeoMatchSetOutcomeCallable UpdateGeoMatchSetCallable(const UpdateGeoMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateGeoMatchSet, request); } /** * An Async wrapper for UpdateGeoMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateGeoMatchSetAsync(const UpdateGeoMatchSetRequestT& request, const UpdateGeoMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateGeoMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * IPSetDescriptor objects in an IPSet. For each * IPSetDescriptor object, you specify the following values:

    *

  • Whether to insert or delete the object from the array. If you want to * change an IPSetDescriptor object, you delete the existing object * and add a new one.

  • The IP address version, IPv4 * or IPv6.

  • The IP address in CIDR notation, for * example, 192.0.2.0/24 (for the range of IP addresses from * 192.0.2.0 to 192.0.2.255) or * 192.0.2.44/32 (for the individual IP address * 192.0.2.44).

AWS WAF supports IPv4 address * ranges: /8 and any range between /16 through /32. AWS WAF supports IPv6 address * ranges: /24, /32, /48, /56, /64, and /128. For more information about CIDR * notation, see the Wikipedia entry Classless * Inter-Domain Routing.

IPv6 addresses can be represented using any of * the following formats:

  • *

    1111:0000:0000:0000:0000:0000:0000:0111/128

  • *

    1111:0:0:0:0:0:0:0111/128

  • 1111::0111/128

  • *

    1111::111/128

You use an IPSet to specify * which web requests you want to allow or block based on the IP addresses that the * requests originated from. For example, if you're receiving a lot of requests * from one or a small number of IP addresses and you want to block the requests, * you can create an IPSet that specifies those IP addresses, and then * configure AWS WAF to block the requests.

To create and configure an * IPSet, perform the following steps:

  1. Submit a * CreateIPSet request.

  2. Use GetChangeToken to get * the change token that you provide in the ChangeToken parameter of * an UpdateIPSet request.

  3. Submit an * UpdateIPSet request to specify the IP addresses that you want AWS * WAF to watch for.

When you update an IPSet, you * specify the IP addresses that you want to add and/or the IP addresses that you * want to delete. If you want to change an IP address, you delete the existing IP * address and add the new one.

You can insert a maximum of 1000 addresses * in a single request.

For more information about how to use the AWS WAF * API to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS API * Reference

*/ virtual Model::UpdateIPSetOutcome UpdateIPSet(const Model::UpdateIPSetRequest& request) const; /** * A Callable wrapper for UpdateIPSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateIPSetOutcomeCallable UpdateIPSetCallable(const UpdateIPSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateIPSet, request); } /** * An Async wrapper for UpdateIPSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateIPSetAsync(const UpdateIPSetRequestT& request, const UpdateIPSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateIPSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * Predicate objects in a rule and updates the RateLimit in the * rule.

Each Predicate object identifies a predicate, such as * a ByteMatchSet or an IPSet, that specifies the web requests that * you want to block or count. The RateLimit specifies the number of * requests every five minutes that triggers the rule.

If you add more than * one predicate to a RateBasedRule, a request must match all the * predicates and exceed the RateLimit to be counted or blocked. For * example, suppose you add the following to a RateBasedRule:

    *

  • An IPSet that matches the IP address * 192.0.2.44/32

  • A ByteMatchSet that * matches BadBot in the User-Agent header

    • *

Further, you specify a RateLimit of 1,000.

You then * add the RateBasedRule to a WebACL and specify that you * want to block requests that satisfy the rule. For a request to be blocked, it * must come from the IP address 192.0.2.44 and the User-Agent * header in the request must contain the value BadBot. Further, * requests that match these two conditions much be received at a rate of more than * 1,000 every five minutes. If the rate drops below this limit, AWS WAF no longer * blocks the requests.

As a second example, suppose you want to limit * requests to a particular page on your site. To do this, you could add the * following to a RateBasedRule:

  • A * ByteMatchSet with FieldToMatch of URI *

  • A PositionalConstraint of * STARTS_WITH

  • A TargetString of * login

Further, you specify a * RateLimit of 1,000.

By adding this * RateBasedRule to a WebACL, you could limit requests to * your login page without affecting the rest of your site.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateRateBasedRuleOutcome UpdateRateBasedRule(const Model::UpdateRateBasedRuleRequest& request) const; /** * A Callable wrapper for UpdateRateBasedRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRateBasedRuleOutcomeCallable UpdateRateBasedRuleCallable(const UpdateRateBasedRuleRequestT& request) const { return SubmitCallable(&WAFClient::UpdateRateBasedRule, request); } /** * An Async wrapper for UpdateRateBasedRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRateBasedRuleAsync(const UpdateRateBasedRuleRequestT& request, const UpdateRateBasedRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateRateBasedRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * RegexMatchTuple objects (filters) in a RegexMatchSet. For each * RegexMatchSetUpdate object, you specify the following values:

*

  • Whether to insert or delete the object from the array. If you want * to change a RegexMatchSetUpdate object, you delete the existing * object and add a new one.

  • The part of a web request that you * want AWS WAF to inspectupdate, such as a query string or the value of the * User-Agent header.

  • The identifier of the pattern * (a regular expression) that you want AWS WAF to look for. For more information, * see RegexPatternSet.

  • Whether to perform any * conversions on the request, such as converting it to lowercase, before * inspecting it for the specified string.

For example, you can * create a RegexPatternSet that matches any requests with * User-Agent headers that contain the string * B[a@]dB[o0]t. You can then configure AWS WAF to reject those * requests.

To create and configure a RegexMatchSet, perform * the following steps:

  1. Create a RegexMatchSet. For * more information, see CreateRegexMatchSet.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateRegexMatchSet * request.

  3. Submit an UpdateRegexMatchSet request to * specify the part of the request that you want AWS WAF to inspect (for example, * the header or the URI) and the identifier of the RegexPatternSet * that contain the regular expression patters you want AWS WAF to watch for.

    *

For more information about how to use the AWS WAF API to allow or * block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRegexMatchSetOutcome UpdateRegexMatchSet(const Model::UpdateRegexMatchSetRequest& request) const; /** * A Callable wrapper for UpdateRegexMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRegexMatchSetOutcomeCallable UpdateRegexMatchSetCallable(const UpdateRegexMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateRegexMatchSet, request); } /** * An Async wrapper for UpdateRegexMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRegexMatchSetAsync(const UpdateRegexMatchSetRequestT& request, const UpdateRegexMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateRegexMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * RegexPatternString objects in a RegexPatternSet. For each * RegexPatternString object, you specify the following values:

*

  • Whether to insert or delete the * RegexPatternString.

  • The regular expression * pattern that you want to insert or delete. For more information, see * RegexPatternSet.

For example, you can create a * RegexPatternString such as B[a@]dB[o0]t. AWS WAF will * match this RegexPatternString to:

  • BadBot

    • *

  • BadB0t

  • B@dBot

  • B@dB0t

*

To create and configure a RegexPatternSet, perform the following * steps:

  1. Create a RegexPatternSet. For more * information, see CreateRegexPatternSet.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateRegexPatternSet * request.

  3. Submit an UpdateRegexPatternSet request * to specify the regular expression pattern that you want AWS WAF to watch * for.

For more information about how to use the AWS WAF API to * allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRegexPatternSetOutcome UpdateRegexPatternSet(const Model::UpdateRegexPatternSetRequest& request) const; /** * A Callable wrapper for UpdateRegexPatternSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRegexPatternSetOutcomeCallable UpdateRegexPatternSetCallable(const UpdateRegexPatternSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateRegexPatternSet, request); } /** * An Async wrapper for UpdateRegexPatternSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRegexPatternSetAsync(const UpdateRegexPatternSetRequestT& request, const UpdateRegexPatternSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateRegexPatternSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * Predicate objects in a Rule. Each Predicate * object identifies a predicate, such as a ByteMatchSet or an IPSet, * that specifies the web requests that you want to allow, block, or count. If you * add more than one predicate to a Rule, a request must match all of * the specifications to be allowed, blocked, or counted. For example, suppose that * you add the following to a Rule:

  • A * ByteMatchSet that matches the value BadBot in the * User-Agent header

  • An IPSet that * matches the IP address 192.0.2.44

You then add * the Rule to a WebACL and specify that you want to * block requests that satisfy the Rule. For a request to be blocked, * the User-Agent header in the request must contain the value * BadBot and the request must originate from the IP address * 192.0.2.44.

To create and configure a Rule, perform the * following steps:

  1. Create and update the predicates that you want * to include in the Rule.

  2. Create the * Rule. See CreateRule.

  3. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateRule request.

    4. *

  4. Submit an UpdateRule request to add predicates to the * Rule.

  5. Create and update a WebACL * that contains the Rule. See CreateWebACL.

*

If you want to replace one ByteMatchSet or IPSet * with another, you delete the existing one and add the new one.

For more * information about how to use the AWS WAF API to allow or block HTTP requests, * see the AWS WAF * Developer Guide.

See Also:

AWS API * Reference

*/ virtual Model::UpdateRuleOutcome UpdateRule(const Model::UpdateRuleRequest& request) const; /** * A Callable wrapper for UpdateRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRuleOutcomeCallable UpdateRuleCallable(const UpdateRuleRequestT& request) const { return SubmitCallable(&WAFClient::UpdateRule, request); } /** * An Async wrapper for UpdateRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRuleAsync(const UpdateRuleRequestT& request, const UpdateRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateRule, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * ActivatedRule objects in a RuleGroup.

You can only * insert REGULAR rules into a rule group.

You can have a * maximum of ten rules per rule group.

To create and configure a * RuleGroup, perform the following steps:

  1. Create and * update the Rules that you want to include in the * RuleGroup. See CreateRule.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateRuleGroup request.

    *

  3. Submit an UpdateRuleGroup request to add * Rules to the RuleGroup.

  4. Create and * update a WebACL that contains the RuleGroup. See * CreateWebACL.

If you want to replace one * Rule with another, you delete the existing one and add the new * one.

For more information about how to use the AWS WAF API to allow or * block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRuleGroupOutcome UpdateRuleGroup(const Model::UpdateRuleGroupRequest& request) const; /** * A Callable wrapper for UpdateRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRuleGroupOutcomeCallable UpdateRuleGroupCallable(const UpdateRuleGroupRequestT& request) const { return SubmitCallable(&WAFClient::UpdateRuleGroup, request); } /** * An Async wrapper for UpdateRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRuleGroupAsync(const UpdateRuleGroupRequestT& request, const UpdateRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateRuleGroup, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * SizeConstraint objects (filters) in a SizeConstraintSet. For each * SizeConstraint object, you specify the following values:

    *

  • Whether to insert or delete the object from the array. If you want to * change a SizeConstraintSetUpdate object, you delete the existing * object and add a new one.

  • The part of a web request that you * want AWS WAF to evaluate, such as the length of a query string or the length of * the User-Agent header.

  • Whether to perform any * transformations on the request, such as converting it to lowercase, before * checking its length. Note that transformations of the request body are not * supported because the AWS resource forwards only the first 8192 * bytes of your request to AWS WAF.

    You can only specify a single type of * TextTransformation.

  • A ComparisonOperator used for * evaluating the selected part of the request against the specified * Size, such as equals, greater than, less than, and so on.

    • *

  • The length, in bytes, that you want AWS WAF to watch for in selected * part of the request. The length is computed after applying the * transformation.

For example, you can add a * SizeConstraintSetUpdate object that matches web requests in which * the length of the User-Agent header is greater than 100 bytes. You * can then configure AWS WAF to block those requests.

To create and * configure a SizeConstraintSet, perform the following steps:

*

  1. Create a SizeConstraintSet. For more information, see * CreateSizeConstraintSet.

  2. Use GetChangeToken to * get the change token that you provide in the ChangeToken parameter * of an UpdateSizeConstraintSet request.

  3. Submit an * UpdateSizeConstraintSet request to specify the part of the request * that you want AWS WAF to inspect (for example, the header or the URI) and the * value that you want AWS WAF to watch for.

For more * information about how to use the AWS WAF API to allow or block HTTP requests, * see the AWS WAF * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSizeConstraintSetOutcome UpdateSizeConstraintSet(const Model::UpdateSizeConstraintSetRequest& request) const; /** * A Callable wrapper for UpdateSizeConstraintSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSizeConstraintSetOutcomeCallable UpdateSizeConstraintSetCallable(const UpdateSizeConstraintSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateSizeConstraintSet, request); } /** * An Async wrapper for UpdateSizeConstraintSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSizeConstraintSetAsync(const UpdateSizeConstraintSetRequestT& request, const UpdateSizeConstraintSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateSizeConstraintSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * SqlInjectionMatchTuple objects (filters) in a * SqlInjectionMatchSet. For each SqlInjectionMatchTuple * object, you specify the following values:

  • Action: * Whether to insert the object into or delete the object from the array. To change * a SqlInjectionMatchTuple, you delete the existing object and add a * new one.

  • FieldToMatch: The part of web requests * that you want AWS WAF to inspect and, if you want AWS WAF to inspect a header or * custom query parameter, the name of the header or parameter.

  • * TextTransformation: Which text transformation, if any, to perform * on the web request before inspecting the request for snippets of malicious SQL * code.

    You can only specify a single type of TextTransformation.

    • *

You use SqlInjectionMatchSet objects to specify which * CloudFront requests that you want to allow, block, or count. For example, if * you're receiving requests that contain snippets of SQL code in the query string * and you want to block the requests, you can create a * SqlInjectionMatchSet with the applicable settings, and then * configure AWS WAF to block the requests.

To create and configure a * SqlInjectionMatchSet, perform the following steps:

  1. *

    Submit a CreateSqlInjectionMatchSet request.

  2. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateIPSet request.

    3. *

  3. Submit an UpdateSqlInjectionMatchSet request to specify the * parts of web requests that you want AWS WAF to inspect for snippets of SQL * code.

For more information about how to use the AWS WAF API * to allow or block HTTP requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateSqlInjectionMatchSetOutcome UpdateSqlInjectionMatchSet(const Model::UpdateSqlInjectionMatchSetRequest& request) const; /** * A Callable wrapper for UpdateSqlInjectionMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateSqlInjectionMatchSetOutcomeCallable UpdateSqlInjectionMatchSetCallable(const UpdateSqlInjectionMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateSqlInjectionMatchSet, request); } /** * An Async wrapper for UpdateSqlInjectionMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateSqlInjectionMatchSetAsync(const UpdateSqlInjectionMatchSetRequestT& request, const UpdateSqlInjectionMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateSqlInjectionMatchSet, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * ActivatedRule objects in a WebACL. Each Rule * identifies web requests that you want to allow, block, or count. When you update * a WebACL, you specify the following values:

  • A * default action for the WebACL, either ALLOW or * BLOCK. AWS WAF performs the default action if a request doesn't * match the criteria in any of the Rules in a * WebACL.

  • The Rules that you want to * add or delete. If you want to replace one Rule with another, you * delete the existing Rule and add the new one.

  • For * each Rule, whether you want AWS WAF to allow requests, block * requests, or count requests that match the conditions in the * Rule.

  • The order in which you want AWS WAF to * evaluate the Rules in a WebACL. If you add more than * one Rule to a WebACL, AWS WAF evaluates each request * against the Rules in order based on the value of * Priority. (The Rule that has the lowest value for * Priority is evaluated first.) When a web request matches all the * predicates (such as ByteMatchSets and IPSets) in a * Rule, AWS WAF immediately takes the corresponding action, allow or * block, and doesn't evaluate the request against the remaining Rules * in the WebACL, if any.

To create and configure * a WebACL, perform the following steps:

  1. Create and * update the predicates that you want to include in Rules. For more * information, see CreateByteMatchSet, UpdateByteMatchSet, * CreateIPSet, UpdateIPSet, CreateSqlInjectionMatchSet, and * UpdateSqlInjectionMatchSet.

  2. Create and update the * Rules that you want to include in the WebACL. For more * information, see CreateRule and UpdateRule.

  3. *

    Create a WebACL. See CreateWebACL.

  4. Use * GetChangeToken to get the change token that you provide in the * ChangeToken parameter of an UpdateWebACL request.

    5. *

  5. Submit an UpdateWebACL request to specify the * Rules that you want to include in the WebACL, to * specify the default action, and to associate the WebACL with a * CloudFront distribution.

    The ActivatedRule can be a rule * group. If you specify a rule group as your ActivatedRule , you can * exclude specific rules from that rule group.

    If you already have a rule * group associated with a web ACL and want to submit an UpdateWebACL * request to exclude certain rules from that rule group, you must first remove the * rule group from the web ACL, the re-insert it again, specifying the excluded * rules. For details, see ActivatedRule$ExcludedRules .

*

Be aware that if you try to add a RATE_BASED rule to a web ACL without * setting the rule type when first creating the rule, the UpdateWebACL * request will fail because the request tries to add a REGULAR rule (the default * rule type) with the specified ID, which does not exist.

For more * information about how to use the AWS WAF API to allow or block HTTP requests, * see the AWS WAF * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateWebACLOutcome UpdateWebACL(const Model::UpdateWebACLRequest& request) const; /** * A Callable wrapper for UpdateWebACL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateWebACLOutcomeCallable UpdateWebACLCallable(const UpdateWebACLRequestT& request) const { return SubmitCallable(&WAFClient::UpdateWebACL, request); } /** * An Async wrapper for UpdateWebACL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateWebACLAsync(const UpdateWebACLRequestT& request, const UpdateWebACLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateWebACL, request, handler, context); } /** *

This is AWS WAF Classic documentation. For more information, * see AWS * WAF Classic in the developer guide.

For the latest version of AWS * WAF, use the AWS WAFV2 API and see the AWS * WAF Developer Guide. With the latest version, AWS WAF has a single set of * endpoints for regional and global use.

Inserts or deletes * XssMatchTuple objects (filters) in an XssMatchSet. For each * XssMatchTuple object, you specify the following values:

    *

  • Action: Whether to insert the object into or delete the * object from the array. To change an XssMatchTuple, you delete the * existing object and add a new one.

  • FieldToMatch: * The part of web requests that you want AWS WAF to inspect and, if you want AWS * WAF to inspect a header or custom query parameter, the name of the header or * parameter.

  • TextTransformation: Which text * transformation, if any, to perform on the web request before inspecting the * request for cross-site scripting attacks.

    You can only specify a single * type of TextTransformation.

You use XssMatchSet * objects to specify which CloudFront requests that you want to allow, block, or * count. For example, if you're receiving requests that contain cross-site * scripting attacks in the request body and you want to block the requests, you * can create an XssMatchSet with the applicable settings, and then * configure AWS WAF to block the requests.

To create and configure an * XssMatchSet, perform the following steps:

  1. Submit a * CreateXssMatchSet request.

  2. Use GetChangeToken to * get the change token that you provide in the ChangeToken parameter * of an UpdateIPSet request.

  3. Submit an * UpdateXssMatchSet request to specify the parts of web requests that * you want AWS WAF to inspect for cross-site scripting attacks.

*

For more information about how to use the AWS WAF API to allow or block HTTP * requests, see the AWS WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateXssMatchSetOutcome UpdateXssMatchSet(const Model::UpdateXssMatchSetRequest& request) const; /** * A Callable wrapper for UpdateXssMatchSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateXssMatchSetOutcomeCallable UpdateXssMatchSetCallable(const UpdateXssMatchSetRequestT& request) const { return SubmitCallable(&WAFClient::UpdateXssMatchSet, request); } /** * An Async wrapper for UpdateXssMatchSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateXssMatchSetAsync(const UpdateXssMatchSetRequestT& request, const UpdateXssMatchSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFClient::UpdateXssMatchSet, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const WAFClientConfiguration& clientConfiguration); WAFClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace WAF } // namespace Aws