/** * 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 WAFV2 { /** * WAF

This is the latest version of the WAF * API, released in November, 2019. The names of the entities that you use to * access this API, like endpoints and namespaces, all have the versioning * information added, like "V2" or "v2", to distinguish from the prior version. We * recommend migrating your resources to this version, because it has a number of * significant improvements.

If you used WAF prior to this release, you * can't use this WAFV2 API to access any WAF resources that you created before. * You can access your old rules, web ACLs, and other WAF resources only through * the WAF Classic APIs. The WAF Classic APIs have retained the prior names, * endpoints, and namespaces.

For information, including how to migrate * your WAF resources to this version, see the WAF * Developer Guide.

WAF is a web application firewall that lets * you monitor the HTTP and HTTPS requests that are forwarded to an Amazon * CloudFront distribution, Amazon API Gateway REST API, Application Load Balancer, * AppSync GraphQL API, Amazon Cognito user pool, App Runner service, or Amazon Web * Services Verified Access instance. WAF also lets you control access to your * content, to protect the Amazon Web Services resource that WAF is monitoring. * Based on conditions that you specify, such as the IP addresses that requests * originate from or the values of query strings, the protected resource responds * to requests with either the requested content, an HTTP 403 status code * (Forbidden), or with a custom response.

This API guide is for developers * who need detailed information about WAF API actions, data types, and errors. For * detailed information about WAF features and guidance for configuring and using * WAF, see the WAF * Developer Guide.

You can make calls using the endpoints listed in WAF endpoints and * quotas.

  • For regional applications, you can use any of the * endpoints in the list. A regional application can be an Application Load * Balancer (ALB), an Amazon API Gateway REST API, an AppSync GraphQL API, an * Amazon Cognito user pool, an App Runner service, or an Amazon Web Services * Verified Access instance.

  • For Amazon CloudFront applications, * you must use the API endpoint listed for US East (N. Virginia): us-east-1.

    *

Alternatively, you can use one of the Amazon Web Services SDKs to * access an API that's tailored to the programming language or platform that * you're using. For more information, see Amazon Web Services SDKs.

We * currently provide two versions of the WAF API: this API and the prior versions, * the classic WAF APIs. This new API provides the same functionality as the older * versions, with the following major improvements:

  • You use one * API for both global and regional applications. Where you need to distinguish the * scope, you specify a Scope parameter and set it to * CLOUDFRONT or REGIONAL.

  • You can * define a web ACL or rule group with a single call, and update it with a single * call. You define all rule specifications in JSON format, and pass them to your * rule group or web ACL calls.

  • The limits WAF places on the use * of rules more closely reflects the cost of running each type of rule. Rule * groups include capacity settings, so you know the maximum cost of a rule group * when you use it.

*/ class AWS_WAFV2_API WAFV2Client : 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 WAFV2ClientConfiguration ClientConfigurationType; typedef WAFV2EndpointProvider 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. */ WAFV2Client(const Aws::WAFV2::WAFV2ClientConfiguration& clientConfiguration = Aws::WAFV2::WAFV2ClientConfiguration(), 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. */ WAFV2Client(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::WAFV2::WAFV2ClientConfiguration& clientConfiguration = Aws::WAFV2::WAFV2ClientConfiguration()); /** * 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 */ WAFV2Client(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::WAFV2::WAFV2ClientConfiguration& clientConfiguration = Aws::WAFV2::WAFV2ClientConfiguration()); /* 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. */ WAFV2Client(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. */ WAFV2Client(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 */ WAFV2Client(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~WAFV2Client(); /** *

Associates a web ACL with a regional application resource, to protect the * resource. A regional application can be an Application Load Balancer (ALB), an * Amazon API Gateway REST API, an AppSync GraphQL API, an Amazon Cognito user * pool, an App Runner service, or an Amazon Web Services Verified Access instance. *

For Amazon CloudFront, don't use this call. Instead, use your CloudFront * distribution configuration. To associate a web ACL, in the CloudFront call * UpdateDistribution, set the web ACL ID to the Amazon Resource Name * (ARN) of the web ACL. For information, see UpdateDistribution * in the Amazon CloudFront Developer Guide.

When you make changes * to web ACLs or web ACL components, like rules and rule groups, WAF propagates * the changes everywhere that the web ACL and its components are stored and used. * Your changes are applied within seconds, but there might be a brief period of * inconsistency when the changes have arrived in some places and not in others. * So, for example, if you change a rule action setting, the action might be the * old action in one area and the new action in another area. Or if you add an IP * address to an IP set used in a blocking rule, the new address might briefly be * blocked in one area while still allowed in another. This temporary inconsistency * can occur when you first associate a web ACL with an Amazon Web Services * resource and when you change a web ACL that is already associated with a * resource. Generally, any inconsistencies of this type last only a few * seconds.

See Also:

AWS * API Reference

*/ virtual Model::AssociateWebACLOutcome AssociateWebACL(const Model::AssociateWebACLRequest& request) const; /** * A Callable wrapper for AssociateWebACL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateWebACLOutcomeCallable AssociateWebACLCallable(const AssociateWebACLRequestT& request) const { return SubmitCallable(&WAFV2Client::AssociateWebACL, request); } /** * An Async wrapper for AssociateWebACL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateWebACLAsync(const AssociateWebACLRequestT& request, const AssociateWebACLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::AssociateWebACL, request, handler, context); } /** *

Returns the web ACL capacity unit (WCU) requirements for a specified scope * and set of rules. You can use this to check the capacity requirements for the * rules you want to use in a RuleGroup or WebACL.

WAF uses * WCUs to calculate and control the operating resources that are used to run your * rules, rule groups, and web ACLs. WAF calculates capacity differently for each * rule type, to reflect the relative cost of each rule. Simple rules that cost * little to run use fewer WCUs than more complex rules that use more processing * power. Rule group capacity is fixed at creation, which helps users plan their * web ACL WCU usage when they use a rule group. For more information, see WAF * web ACL capacity units (WCU) in the WAF Developer Guide. *

See Also:

AWS * API Reference

*/ virtual Model::CheckCapacityOutcome CheckCapacity(const Model::CheckCapacityRequest& request) const; /** * A Callable wrapper for CheckCapacity that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CheckCapacityOutcomeCallable CheckCapacityCallable(const CheckCapacityRequestT& request) const { return SubmitCallable(&WAFV2Client::CheckCapacity, request); } /** * An Async wrapper for CheckCapacity that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CheckCapacityAsync(const CheckCapacityRequestT& request, const CheckCapacityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::CheckCapacity, request, handler, context); } /** *

Creates an API key that contains a set of token domains.

API keys are * required for the integration of the CAPTCHA API in your JavaScript client * applications. The API lets you customize the placement and characteristics of * the CAPTCHA puzzle for your end users. For more information about the CAPTCHA * JavaScript integration, see WAF * client application integration in the WAF Developer Guide.

You * can use a single key for up to 5 domains. After you generate a key, you can copy * it for use in your JavaScript integration.

See Also:

AWS * API Reference

*/ virtual Model::CreateAPIKeyOutcome CreateAPIKey(const Model::CreateAPIKeyRequest& request) const; /** * A Callable wrapper for CreateAPIKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAPIKeyOutcomeCallable CreateAPIKeyCallable(const CreateAPIKeyRequestT& request) const { return SubmitCallable(&WAFV2Client::CreateAPIKey, request); } /** * An Async wrapper for CreateAPIKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAPIKeyAsync(const CreateAPIKeyRequestT& request, const CreateAPIKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::CreateAPIKey, request, handler, context); } /** *

Creates an IPSet, which you use to identify web requests that * originate from specific IP addresses or ranges of IP addresses. For example, if * you're receiving a lot of requests from a ranges of IP addresses, you can * configure WAF to block them using an IPSet that lists those IP addresses. *

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(&WAFV2Client::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(&WAFV2Client::CreateIPSet, request, handler, context); } /** *

Creates a RegexPatternSet, which you reference in a * RegexPatternSetReferenceStatement, to have WAF inspect a web request * component for the specified patterns.

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(&WAFV2Client::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(&WAFV2Client::CreateRegexPatternSet, request, handler, context); } /** *

Creates a RuleGroup per the specifications provided.

A rule * group defines a collection of rules to inspect and control web requests that you * can use in a WebACL. When you create a rule group, you define an * immutable capacity limit. If you update a rule group, you must stay within the * capacity. This allows others to reuse the rule group with confidence in its * capacity requirements.

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(&WAFV2Client::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(&WAFV2Client::CreateRuleGroup, request, handler, context); } /** *

Creates a WebACL per the specifications provided.

A web ACL * defines a collection of rules to use to inspect and control web requests. Each * rule has an action defined (allow, block, or count) for requests that match the * statement of the rule. In the web ACL, you assign a default action to take * (allow, block) for any request that does not match any of the rules. The rules * in a web ACL can be a combination of the types Rule, RuleGroup, * and managed rule group. You can associate a web ACL with one or more Amazon Web * Services resources to protect. The resources can be an Amazon CloudFront * distribution, an Amazon API Gateway REST API, an Application Load Balancer, an * AppSync GraphQL API, an Amazon Cognito user pool, an App Runner service, or an * Amazon Web Services Verified Access instance.

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(&WAFV2Client::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(&WAFV2Client::CreateWebACL, request, handler, context); } /** *

Deletes all rule groups that are managed by Firewall Manager for the * specified web ACL.

You can only use this if * ManagedByFirewallManager is false in the specified WebACL. *

See Also:

AWS * API Reference

*/ virtual Model::DeleteFirewallManagerRuleGroupsOutcome DeleteFirewallManagerRuleGroups(const Model::DeleteFirewallManagerRuleGroupsRequest& request) const; /** * A Callable wrapper for DeleteFirewallManagerRuleGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFirewallManagerRuleGroupsOutcomeCallable DeleteFirewallManagerRuleGroupsCallable(const DeleteFirewallManagerRuleGroupsRequestT& request) const { return SubmitCallable(&WAFV2Client::DeleteFirewallManagerRuleGroups, request); } /** * An Async wrapper for DeleteFirewallManagerRuleGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFirewallManagerRuleGroupsAsync(const DeleteFirewallManagerRuleGroupsRequestT& request, const DeleteFirewallManagerRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::DeleteFirewallManagerRuleGroups, request, handler, context); } /** *

Deletes the specified IPSet.

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(&WAFV2Client::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(&WAFV2Client::DeleteIPSet, request, handler, context); } /** *

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(&WAFV2Client::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(&WAFV2Client::DeleteLoggingConfiguration, request, handler, context); } /** *

Permanently deletes an IAM policy from the specified rule group.

You * must be the owner of the rule group to perform this operation.

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(&WAFV2Client::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(&WAFV2Client::DeletePermissionPolicy, request, handler, context); } /** *

Deletes the specified RegexPatternSet.

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(&WAFV2Client::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(&WAFV2Client::DeleteRegexPatternSet, request, handler, context); } /** *

Deletes the specified RuleGroup.

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(&WAFV2Client::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(&WAFV2Client::DeleteRuleGroup, request, handler, context); } /** *

Deletes the specified WebACL.

You can only use this if * ManagedByFirewallManager is false in the specified WebACL. *

Before deleting any web ACL, first disassociate it from all * resources.

  • To retrieve a list of the resources that are * associated with a web ACL, use the following calls:

  • To * disassociate a resource from a web ACL, use the following calls:

    • *

      For regional resources, call DisassociateWebACL.

    • For * Amazon CloudFront distributions, provide an empty web ACL ID in the CloudFront * call UpdateDistribution. For information, see UpdateDistribution * in the Amazon CloudFront API Reference.

*

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(&WAFV2Client::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(&WAFV2Client::DeleteWebACL, request, handler, context); } /** *

Provides high-level information for the Amazon Web Services Managed Rules * rule groups and Amazon Web Services Marketplace managed rule groups. *

See Also:

AWS * API Reference

*/ virtual Model::DescribeAllManagedProductsOutcome DescribeAllManagedProducts(const Model::DescribeAllManagedProductsRequest& request) const; /** * A Callable wrapper for DescribeAllManagedProducts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAllManagedProductsOutcomeCallable DescribeAllManagedProductsCallable(const DescribeAllManagedProductsRequestT& request) const { return SubmitCallable(&WAFV2Client::DescribeAllManagedProducts, request); } /** * An Async wrapper for DescribeAllManagedProducts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAllManagedProductsAsync(const DescribeAllManagedProductsRequestT& request, const DescribeAllManagedProductsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::DescribeAllManagedProducts, request, handler, context); } /** *

Provides high-level information for the managed rule groups owned by a * specific vendor.

See Also:

AWS * API Reference

*/ virtual Model::DescribeManagedProductsByVendorOutcome DescribeManagedProductsByVendor(const Model::DescribeManagedProductsByVendorRequest& request) const; /** * A Callable wrapper for DescribeManagedProductsByVendor that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeManagedProductsByVendorOutcomeCallable DescribeManagedProductsByVendorCallable(const DescribeManagedProductsByVendorRequestT& request) const { return SubmitCallable(&WAFV2Client::DescribeManagedProductsByVendor, request); } /** * An Async wrapper for DescribeManagedProductsByVendor that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeManagedProductsByVendorAsync(const DescribeManagedProductsByVendorRequestT& request, const DescribeManagedProductsByVendorResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::DescribeManagedProductsByVendor, request, handler, context); } /** *

Provides high-level information for a managed rule group, including * descriptions of the rules.

See Also:

AWS * API Reference

*/ virtual Model::DescribeManagedRuleGroupOutcome DescribeManagedRuleGroup(const Model::DescribeManagedRuleGroupRequest& request) const; /** * A Callable wrapper for DescribeManagedRuleGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeManagedRuleGroupOutcomeCallable DescribeManagedRuleGroupCallable(const DescribeManagedRuleGroupRequestT& request) const { return SubmitCallable(&WAFV2Client::DescribeManagedRuleGroup, request); } /** * An Async wrapper for DescribeManagedRuleGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeManagedRuleGroupAsync(const DescribeManagedRuleGroupRequestT& request, const DescribeManagedRuleGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::DescribeManagedRuleGroup, request, handler, context); } /** *

Disassociates the specified regional application resource from any existing * web ACL association. A resource can have at most one web ACL association. A * regional application can be an Application Load Balancer (ALB), an Amazon API * Gateway REST API, an AppSync GraphQL API, an Amazon Cognito user pool, an App * Runner service, or an Amazon Web Services Verified Access instance.

For * Amazon CloudFront, don't use this call. Instead, use your CloudFront * distribution configuration. To disassociate a web ACL, provide an empty web ACL * ID in the CloudFront call UpdateDistribution. For information, see * UpdateDistribution * in the Amazon CloudFront API Reference.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateWebACLOutcome DisassociateWebACL(const Model::DisassociateWebACLRequest& request) const; /** * A Callable wrapper for DisassociateWebACL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateWebACLOutcomeCallable DisassociateWebACLCallable(const DisassociateWebACLRequestT& request) const { return SubmitCallable(&WAFV2Client::DisassociateWebACL, request); } /** * An Async wrapper for DisassociateWebACL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateWebACLAsync(const DisassociateWebACLRequestT& request, const DisassociateWebACLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::DisassociateWebACL, request, handler, context); } /** *

Generates a presigned download URL for the specified release of the mobile * SDK.

The mobile SDK is not generally available. Customers who have access * to the mobile SDK can use it to establish and manage WAF tokens for use in * HTTP(S) requests from a mobile device to WAF. For more information, see WAF * client application integration in the WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GenerateMobileSdkReleaseUrlOutcome GenerateMobileSdkReleaseUrl(const Model::GenerateMobileSdkReleaseUrlRequest& request) const; /** * A Callable wrapper for GenerateMobileSdkReleaseUrl that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GenerateMobileSdkReleaseUrlOutcomeCallable GenerateMobileSdkReleaseUrlCallable(const GenerateMobileSdkReleaseUrlRequestT& request) const { return SubmitCallable(&WAFV2Client::GenerateMobileSdkReleaseUrl, request); } /** * An Async wrapper for GenerateMobileSdkReleaseUrl that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GenerateMobileSdkReleaseUrlAsync(const GenerateMobileSdkReleaseUrlRequestT& request, const GenerateMobileSdkReleaseUrlResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::GenerateMobileSdkReleaseUrl, request, handler, context); } /** *

Returns your API key in decrypted form. Use this to check the token domains * that you have defined for the key.

API keys are required for the * integration of the CAPTCHA API in your JavaScript client applications. The API * lets you customize the placement and characteristics of the CAPTCHA puzzle for * your end users. For more information about the CAPTCHA JavaScript integration, * see WAF * client application integration in the WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetDecryptedAPIKeyOutcome GetDecryptedAPIKey(const Model::GetDecryptedAPIKeyRequest& request) const; /** * A Callable wrapper for GetDecryptedAPIKey that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDecryptedAPIKeyOutcomeCallable GetDecryptedAPIKeyCallable(const GetDecryptedAPIKeyRequestT& request) const { return SubmitCallable(&WAFV2Client::GetDecryptedAPIKey, request); } /** * An Async wrapper for GetDecryptedAPIKey that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDecryptedAPIKeyAsync(const GetDecryptedAPIKeyRequestT& request, const GetDecryptedAPIKeyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::GetDecryptedAPIKey, request, handler, context); } /** *

Retrieves the specified IPSet.

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(&WAFV2Client::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(&WAFV2Client::GetIPSet, request, handler, context); } /** *

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(&WAFV2Client::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(&WAFV2Client::GetLoggingConfiguration, request, handler, context); } /** *

Retrieves the specified managed rule set.

This is intended for * use only by vendors of managed rule sets. Vendors are Amazon Web Services and * Amazon Web Services Marketplace sellers.

Vendors, you can use the * managed rule set APIs to provide controlled rollout of your versioned managed * rule group offerings for your customers. The APIs are * ListManagedRuleSets, GetManagedRuleSet, * PutManagedRuleSetVersions, and * UpdateManagedRuleSetVersionExpiryDate.

See * Also:

AWS * API Reference

*/ virtual Model::GetManagedRuleSetOutcome GetManagedRuleSet(const Model::GetManagedRuleSetRequest& request) const; /** * A Callable wrapper for GetManagedRuleSet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetManagedRuleSetOutcomeCallable GetManagedRuleSetCallable(const GetManagedRuleSetRequestT& request) const { return SubmitCallable(&WAFV2Client::GetManagedRuleSet, request); } /** * An Async wrapper for GetManagedRuleSet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetManagedRuleSetAsync(const GetManagedRuleSetRequestT& request, const GetManagedRuleSetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::GetManagedRuleSet, request, handler, context); } /** *

Retrieves information for the specified mobile SDK release, including release * notes and tags.

The mobile SDK is not generally available. Customers who * have access to the mobile SDK can use it to establish and manage WAF tokens for * use in HTTP(S) requests from a mobile device to WAF. For more information, see * WAF * client application integration in the WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetMobileSdkReleaseOutcome GetMobileSdkRelease(const Model::GetMobileSdkReleaseRequest& request) const; /** * A Callable wrapper for GetMobileSdkRelease that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMobileSdkReleaseOutcomeCallable GetMobileSdkReleaseCallable(const GetMobileSdkReleaseRequestT& request) const { return SubmitCallable(&WAFV2Client::GetMobileSdkRelease, request); } /** * An Async wrapper for GetMobileSdkRelease that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMobileSdkReleaseAsync(const GetMobileSdkReleaseRequestT& request, const GetMobileSdkReleaseResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::GetMobileSdkRelease, request, handler, context); } /** *

Returns the IAM policy that is attached to the specified rule group.

*

You must be the owner of the rule group to perform this * operation.

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(&WAFV2Client::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(&WAFV2Client::GetPermissionPolicy, request, handler, context); } /** *

Retrieves the IP addresses that are currently blocked by a rate-based rule * instance. This is only available for rate-based rules that aggregate solely on * the IP address or on the forwarded IP address.

The maximum number of * addresses that can be blocked for a single rate-based rule instance is 10,000. * If more than 10,000 addresses exceed the rate limit, those with the highest * rates are blocked.

For a rate-based rule that you've defined inside a * rule group, provide the name of the rule group reference statement in your * request, in addition to the rate-based rule name and the web ACL name.

*

WAF monitors web requests and manages keys independently for each unique * combination of web ACL, optional rule group, and rate-based rule. For example, * if you define a rate-based rule inside a rule group, and then use the rule group * in a web ACL, WAF monitors web requests and manages keys for that web ACL, rule * group reference statement, and rate-based rule instance. If you use the same * rule group in a second web ACL, WAF monitors web requests and manages keys for * this second usage completely independent of your first.

See * Also:

AWS * API Reference

*/ virtual Model::GetRateBasedStatementManagedKeysOutcome GetRateBasedStatementManagedKeys(const Model::GetRateBasedStatementManagedKeysRequest& request) const; /** * A Callable wrapper for GetRateBasedStatementManagedKeys that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRateBasedStatementManagedKeysOutcomeCallable GetRateBasedStatementManagedKeysCallable(const GetRateBasedStatementManagedKeysRequestT& request) const { return SubmitCallable(&WAFV2Client::GetRateBasedStatementManagedKeys, request); } /** * An Async wrapper for GetRateBasedStatementManagedKeys that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRateBasedStatementManagedKeysAsync(const GetRateBasedStatementManagedKeysRequestT& request, const GetRateBasedStatementManagedKeysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::GetRateBasedStatementManagedKeys, request, handler, context); } /** *

Retrieves the specified RegexPatternSet.

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(&WAFV2Client::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(&WAFV2Client::GetRegexPatternSet, request, handler, context); } /** *

Retrieves the specified RuleGroup.

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(&WAFV2Client::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(&WAFV2Client::GetRuleGroup, request, handler, context); } /** *

Gets detailed information about a specified number of requests--a * sample--that WAF randomly selects from among the first 5,000 requests that your * Amazon Web Services 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 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(&WAFV2Client::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(&WAFV2Client::GetSampledRequests, request, handler, context); } /** *

Retrieves the specified WebACL.

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(&WAFV2Client::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(&WAFV2Client::GetWebACL, request, handler, context); } /** *

Retrieves the WebACL for the specified resource.

See * Also:

AWS * API Reference

*/ virtual Model::GetWebACLForResourceOutcome GetWebACLForResource(const Model::GetWebACLForResourceRequest& request) const; /** * A Callable wrapper for GetWebACLForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetWebACLForResourceOutcomeCallable GetWebACLForResourceCallable(const GetWebACLForResourceRequestT& request) const { return SubmitCallable(&WAFV2Client::GetWebACLForResource, request); } /** * An Async wrapper for GetWebACLForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetWebACLForResourceAsync(const GetWebACLForResourceRequestT& request, const GetWebACLForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::GetWebACLForResource, request, handler, context); } /** *

Retrieves a list of the API keys that you've defined for the specified scope. *

API keys are required for the integration of the CAPTCHA API in your * JavaScript client applications. The API lets you customize the placement and * characteristics of the CAPTCHA puzzle for your end users. For more information * about the CAPTCHA JavaScript integration, see WAF * client application integration in the WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListAPIKeysOutcome ListAPIKeys(const Model::ListAPIKeysRequest& request) const; /** * A Callable wrapper for ListAPIKeys that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAPIKeysOutcomeCallable ListAPIKeysCallable(const ListAPIKeysRequestT& request) const { return SubmitCallable(&WAFV2Client::ListAPIKeys, request); } /** * An Async wrapper for ListAPIKeys that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAPIKeysAsync(const ListAPIKeysRequestT& request, const ListAPIKeysResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::ListAPIKeys, request, handler, context); } /** *

Returns a list of the available versions for the specified managed rule * group.

See Also:

AWS * API Reference

*/ virtual Model::ListAvailableManagedRuleGroupVersionsOutcome ListAvailableManagedRuleGroupVersions(const Model::ListAvailableManagedRuleGroupVersionsRequest& request) const; /** * A Callable wrapper for ListAvailableManagedRuleGroupVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAvailableManagedRuleGroupVersionsOutcomeCallable ListAvailableManagedRuleGroupVersionsCallable(const ListAvailableManagedRuleGroupVersionsRequestT& request) const { return SubmitCallable(&WAFV2Client::ListAvailableManagedRuleGroupVersions, request); } /** * An Async wrapper for ListAvailableManagedRuleGroupVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAvailableManagedRuleGroupVersionsAsync(const ListAvailableManagedRuleGroupVersionsRequestT& request, const ListAvailableManagedRuleGroupVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::ListAvailableManagedRuleGroupVersions, request, handler, context); } /** *

Retrieves an array of managed rule groups that are available for you to use. * This list includes all Amazon Web Services Managed Rules rule groups and all of * the Amazon Web Services Marketplace managed rule groups that you're subscribed * to.

See Also:

AWS * API Reference

*/ virtual Model::ListAvailableManagedRuleGroupsOutcome ListAvailableManagedRuleGroups(const Model::ListAvailableManagedRuleGroupsRequest& request) const; /** * A Callable wrapper for ListAvailableManagedRuleGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAvailableManagedRuleGroupsOutcomeCallable ListAvailableManagedRuleGroupsCallable(const ListAvailableManagedRuleGroupsRequestT& request) const { return SubmitCallable(&WAFV2Client::ListAvailableManagedRuleGroups, request); } /** * An Async wrapper for ListAvailableManagedRuleGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAvailableManagedRuleGroupsAsync(const ListAvailableManagedRuleGroupsRequestT& request, const ListAvailableManagedRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::ListAvailableManagedRuleGroups, request, handler, context); } /** *

Retrieves an array of IPSetSummary objects for the IP sets that you * manage.

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(&WAFV2Client::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(&WAFV2Client::ListIPSets, request, handler, context); } /** *

Retrieves an array of your 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(&WAFV2Client::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(&WAFV2Client::ListLoggingConfigurations, request, handler, context); } /** *

Retrieves the managed rule sets that you own.

This is intended * for use only by vendors of managed rule sets. Vendors are Amazon Web Services * and Amazon Web Services Marketplace sellers.

Vendors, you can use the * managed rule set APIs to provide controlled rollout of your versioned managed * rule group offerings for your customers. The APIs are * ListManagedRuleSets, GetManagedRuleSet, * PutManagedRuleSetVersions, and * UpdateManagedRuleSetVersionExpiryDate.

See * Also:

AWS * API Reference

*/ virtual Model::ListManagedRuleSetsOutcome ListManagedRuleSets(const Model::ListManagedRuleSetsRequest& request) const; /** * A Callable wrapper for ListManagedRuleSets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListManagedRuleSetsOutcomeCallable ListManagedRuleSetsCallable(const ListManagedRuleSetsRequestT& request) const { return SubmitCallable(&WAFV2Client::ListManagedRuleSets, request); } /** * An Async wrapper for ListManagedRuleSets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListManagedRuleSetsAsync(const ListManagedRuleSetsRequestT& request, const ListManagedRuleSetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::ListManagedRuleSets, request, handler, context); } /** *

Retrieves a list of the available releases for the mobile SDK and the * specified device platform.

The mobile SDK is not generally available. * Customers who have access to the mobile SDK can use it to establish and manage * WAF tokens for use in HTTP(S) requests from a mobile device to WAF. For more * information, see WAF * client application integration in the WAF Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListMobileSdkReleasesOutcome ListMobileSdkReleases(const Model::ListMobileSdkReleasesRequest& request) const; /** * A Callable wrapper for ListMobileSdkReleases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMobileSdkReleasesOutcomeCallable ListMobileSdkReleasesCallable(const ListMobileSdkReleasesRequestT& request) const { return SubmitCallable(&WAFV2Client::ListMobileSdkReleases, request); } /** * An Async wrapper for ListMobileSdkReleases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMobileSdkReleasesAsync(const ListMobileSdkReleasesRequestT& request, const ListMobileSdkReleasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::ListMobileSdkReleases, request, handler, context); } /** *

Retrieves an array of RegexPatternSetSummary objects for the regex * pattern sets that you manage.

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(&WAFV2Client::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(&WAFV2Client::ListRegexPatternSets, request, handler, context); } /** *

Retrieves an array of the Amazon Resource Names (ARNs) for the regional * resources that are associated with the specified web ACL. If you want the list * of Amazon CloudFront resources, use the CloudFront call * ListDistributionsByWebACLId.

See Also:

AWS * API Reference

*/ virtual Model::ListResourcesForWebACLOutcome ListResourcesForWebACL(const Model::ListResourcesForWebACLRequest& request) const; /** * A Callable wrapper for ListResourcesForWebACL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResourcesForWebACLOutcomeCallable ListResourcesForWebACLCallable(const ListResourcesForWebACLRequestT& request) const { return SubmitCallable(&WAFV2Client::ListResourcesForWebACL, request); } /** * An Async wrapper for ListResourcesForWebACL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResourcesForWebACLAsync(const ListResourcesForWebACLRequestT& request, const ListResourcesForWebACLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::ListResourcesForWebACL, request, handler, context); } /** *

Retrieves an array of RuleGroupSummary objects for the rule groups * that you manage.

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(&WAFV2Client::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(&WAFV2Client::ListRuleGroups, request, handler, context); } /** *

Retrieves the TagInfoForResource for the specified 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 Amazon Web Services resource, up to 50 tags for a resource.

You can * tag the Amazon Web Services resources that you manage through WAF: web ACLs, * rule groups, IP sets, and regex pattern sets. You can't manage or view tags * through the WAF console.

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(&WAFV2Client::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(&WAFV2Client::ListTagsForResource, request, handler, context); } /** *

Retrieves an array of WebACLSummary objects for the web ACLs that you * manage.

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(&WAFV2Client::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(&WAFV2Client::ListWebACLs, request, handler, context); } /** *

Enables the specified LoggingConfiguration, to start logging from a * web ACL, according to the configuration provided.

This operation * completely replaces any mutable specifications that you already have for a * logging configuration with the ones that you provide to this call.

To * modify an existing logging configuration, do the following:

  1. *

    Retrieve it by calling GetLoggingConfiguration

  2. *

    Update its settings as needed

  3. Provide the complete logging * configuration specification to this call

You * can define one logging destination per web ACL.

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

*

  1. Create your logging destination. You can use an Amazon CloudWatch * Logs log group, an Amazon Simple Storage Service (Amazon S3) bucket, or an * Amazon Kinesis Data Firehose.

    The name that you give the destination * must start with aws-waf-logs-. Depending on the type of * destination, you might need to configure additional settings or permissions. *

    For configuration requirements and pricing information for each * destination type, see Logging * web ACL traffic in the WAF Developer Guide.

  2. *

    Associate your logging destination to your web ACL using a * PutLoggingConfiguration request.

When you * successfully enable logging using a PutLoggingConfiguration * request, WAF creates an additional role or policy that is required to write logs * to the logging destination. For an Amazon CloudWatch Logs log group, WAF creates * a resource policy on the log group. For an Amazon S3 bucket, WAF creates a * bucket policy. For an Amazon Kinesis Data Firehose, WAF creates a service-linked * role.

For additional information about web ACL logging, see Logging * web ACL traffic information in the 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(&WAFV2Client::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(&WAFV2Client::PutLoggingConfiguration, request, handler, context); } /** *

Defines the versions of your managed rule set that you are offering to the * customers. Customers see your offerings as managed rule groups with * versioning.

This is intended for use only by vendors of managed * rule sets. Vendors are Amazon Web Services and Amazon Web Services Marketplace * sellers.

Vendors, you can use the managed rule set APIs to provide * controlled rollout of your versioned managed rule group offerings for your * customers. The APIs are ListManagedRuleSets, * GetManagedRuleSet, PutManagedRuleSetVersions, and * UpdateManagedRuleSetVersionExpiryDate.

Customers * retrieve their managed rule group list by calling * ListAvailableManagedRuleGroups. The name that you provide here for your * managed rule set is the name the customer sees for the corresponding managed * rule group. Customers can retrieve the available versions for a managed rule * group by calling ListAvailableManagedRuleGroupVersions. You provide a * rule group specification for each version. For each managed rule set, you must * specify a version that you recommend using.

To initiate the expiration * of a managed rule group version, use * UpdateManagedRuleSetVersionExpiryDate.

See Also:

AWS * API Reference

*/ virtual Model::PutManagedRuleSetVersionsOutcome PutManagedRuleSetVersions(const Model::PutManagedRuleSetVersionsRequest& request) const; /** * A Callable wrapper for PutManagedRuleSetVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutManagedRuleSetVersionsOutcomeCallable PutManagedRuleSetVersionsCallable(const PutManagedRuleSetVersionsRequestT& request) const { return SubmitCallable(&WAFV2Client::PutManagedRuleSetVersions, request); } /** * An Async wrapper for PutManagedRuleSetVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutManagedRuleSetVersionsAsync(const PutManagedRuleSetVersionsRequestT& request, const PutManagedRuleSetVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::PutManagedRuleSetVersions, request, handler, context); } /** *

Attaches an IAM policy to the specified resource. Use this to share a rule * group across accounts.

You must be the owner of the rule group to perform * this operation.

This action is subject to the following restrictions:

*

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

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

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

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(&WAFV2Client::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(&WAFV2Client::PutPermissionPolicy, request, handler, context); } /** *

Associates tags with the specified Amazon Web Services 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 Amazon Web Services resource, up to 50 tags for a resource.

You can * tag the Amazon Web Services resources that you manage through WAF: web ACLs, * rule groups, IP sets, and regex pattern sets. You can't manage or view tags * through the WAF console.

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(&WAFV2Client::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(&WAFV2Client::TagResource, request, handler, context); } /** *

Disassociates tags from an Amazon Web Services resource. Tags are key:value * pairs that you can associate with Amazon Web Services resources. For example, * the tag key might be "customer" and the tag value might be "companyA." You can * specify one or more tags to add to each container. You can add up to 50 tags to * each Amazon Web Services resource.

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(&WAFV2Client::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(&WAFV2Client::UntagResource, request, handler, context); } /** *

Updates the specified IPSet.

This operation completely * replaces the mutable specifications that you already have for the IP set with * the ones that you provide to this call.

To modify an IP set, do the * following:

  1. Retrieve it by calling GetIPSet

    2. *

  2. Update its settings as needed

  3. Provide the complete IP * set specification to this call

When you make changes * to web ACLs or web ACL components, like rules and rule groups, WAF propagates * the changes everywhere that the web ACL and its components are stored and used. * Your changes are applied within seconds, but there might be a brief period of * inconsistency when the changes have arrived in some places and not in others. * So, for example, if you change a rule action setting, the action might be the * old action in one area and the new action in another area. Or if you add an IP * address to an IP set used in a blocking rule, the new address might briefly be * blocked in one area while still allowed in another. This temporary inconsistency * can occur when you first associate a web ACL with an Amazon Web Services * resource and when you change a web ACL that is already associated with a * resource. Generally, any inconsistencies of this type last only a few * seconds.

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(&WAFV2Client::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(&WAFV2Client::UpdateIPSet, request, handler, context); } /** *

Updates the expiration information for your managed rule set. Use this to * initiate the expiration of a managed rule group version. After you initiate * expiration for a version, WAF excludes it from the response to * ListAvailableManagedRuleGroupVersions for the managed rule group.

*

This is intended for use only by vendors of managed rule sets. Vendors * are Amazon Web Services and Amazon Web Services Marketplace sellers.

*

Vendors, you can use the managed rule set APIs to provide controlled rollout * of your versioned managed rule group offerings for your customers. The APIs are * ListManagedRuleSets, GetManagedRuleSet, * PutManagedRuleSetVersions, and * UpdateManagedRuleSetVersionExpiryDate.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateManagedRuleSetVersionExpiryDateOutcome UpdateManagedRuleSetVersionExpiryDate(const Model::UpdateManagedRuleSetVersionExpiryDateRequest& request) const; /** * A Callable wrapper for UpdateManagedRuleSetVersionExpiryDate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateManagedRuleSetVersionExpiryDateOutcomeCallable UpdateManagedRuleSetVersionExpiryDateCallable(const UpdateManagedRuleSetVersionExpiryDateRequestT& request) const { return SubmitCallable(&WAFV2Client::UpdateManagedRuleSetVersionExpiryDate, request); } /** * An Async wrapper for UpdateManagedRuleSetVersionExpiryDate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateManagedRuleSetVersionExpiryDateAsync(const UpdateManagedRuleSetVersionExpiryDateRequestT& request, const UpdateManagedRuleSetVersionExpiryDateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WAFV2Client::UpdateManagedRuleSetVersionExpiryDate, request, handler, context); } /** *

Updates the specified RegexPatternSet.

This operation * completely replaces the mutable specifications that you already have for the * regex pattern set with the ones that you provide to this call.

To modify * a regex pattern set, do the following:

  1. Retrieve it by calling * GetRegexPatternSet

  2. Update its settings as needed

    *

  3. Provide the complete regex pattern set specification to this * call

When you make changes to web ACLs or web ACL * components, like rules and rule groups, WAF propagates the changes everywhere * that the web ACL and its components are stored and used. Your changes are * applied within seconds, but there might be a brief period of inconsistency when * the changes have arrived in some places and not in others. So, for example, if * you change a rule action setting, the action might be the old action in one area * and the new action in another area. Or if you add an IP address to an IP set * used in a blocking rule, the new address might briefly be blocked in one area * while still allowed in another. This temporary inconsistency can occur when you * first associate a web ACL with an Amazon Web Services resource and when you * change a web ACL that is already associated with a resource. Generally, any * inconsistencies of this type last only a few seconds.

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(&WAFV2Client::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(&WAFV2Client::UpdateRegexPatternSet, request, handler, context); } /** *

Updates the specified RuleGroup.

This operation * completely replaces the mutable specifications that you already have for the * rule group with the ones that you provide to this call.

To modify a rule * group, do the following:

  1. Retrieve it by calling * GetRuleGroup

  2. Update its settings as needed

    3. *

  3. Provide the complete rule group specification to this call

    4. *

When you make changes to web ACLs or web ACL components, like * rules and rule groups, WAF propagates the changes everywhere that the web ACL * and its components are stored and used. Your changes are applied within seconds, * but there might be a brief period of inconsistency when the changes have arrived * in some places and not in others. So, for example, if you change a rule action * setting, the action might be the old action in one area and the new action in * another area. Or if you add an IP address to an IP set used in a blocking rule, * the new address might briefly be blocked in one area while still allowed in * another. This temporary inconsistency can occur when you first associate a web * ACL with an Amazon Web Services resource and when you change a web ACL that is * already associated with a resource. Generally, any inconsistencies of this type * last only a few seconds.

A rule group defines a collection of rules to * inspect and control web requests that you can use in a WebACL. When you * create a rule group, you define an immutable capacity limit. If you update a * rule group, you must stay within the capacity. This allows others to reuse the * rule group with confidence in its capacity requirements.

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(&WAFV2Client::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(&WAFV2Client::UpdateRuleGroup, request, handler, context); } /** *

Updates the specified WebACL. While updating a web ACL, WAF provides * continuous coverage to the resources that you have associated with the web ACL. *

This operation completely replaces the mutable specifications * that you already have for the web ACL with the ones that you provide to this * call.

To modify a web ACL, do the following:

  1. Retrieve * it by calling GetWebACL

  2. Update its settings as * needed

  3. Provide the complete web ACL specification to this * call

When you make changes to web ACLs or web ACL * components, like rules and rule groups, WAF propagates the changes everywhere * that the web ACL and its components are stored and used. Your changes are * applied within seconds, but there might be a brief period of inconsistency when * the changes have arrived in some places and not in others. So, for example, if * you change a rule action setting, the action might be the old action in one area * and the new action in another area. Or if you add an IP address to an IP set * used in a blocking rule, the new address might briefly be blocked in one area * while still allowed in another. This temporary inconsistency can occur when you * first associate a web ACL with an Amazon Web Services resource and when you * change a web ACL that is already associated with a resource. Generally, any * inconsistencies of this type last only a few seconds.

A web ACL defines * a collection of rules to use to inspect and control web requests. Each rule has * an action defined (allow, block, or count) for requests that match the statement * of the rule. In the web ACL, you assign a default action to take (allow, block) * for any request that does not match any of the rules. The rules in a web ACL can * be a combination of the types Rule, RuleGroup, and managed rule * group. You can associate a web ACL with one or more Amazon Web Services * resources to protect. The resources can be an Amazon CloudFront distribution, an * Amazon API Gateway REST API, an Application Load Balancer, an AppSync GraphQL * API, an Amazon Cognito user pool, an App Runner service, or an Amazon Web * Services Verified Access instance.

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(&WAFV2Client::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(&WAFV2Client::UpdateWebACL, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const WAFV2ClientConfiguration& clientConfiguration); WAFV2ClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace WAFV2 } // namespace Aws