@aws-sdk/client-waf 3.32.0 → 3.36.0

package/dist-types/commands/ListRegexPatternSetsCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListRegexPatternSetsRequest, ListRegexPatternSetsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListRegexPatternSetsCommandInput extends ListRegexPatternSetsRequest {
+}
+export interface ListRegexPatternSetsCommandOutput extends ListRegexPatternSetsResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *          <p>Returns an array of <a>RegexPatternSetSummary</a> objects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListRegexPatternSetsCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListRegexPatternSetsCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListRegexPatternSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListRegexPatternSetsCommandInput} for command's `input` shape.
+ * @see {@link ListRegexPatternSetsCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListRegexPatternSetsCommand extends $Command<ListRegexPatternSetsCommandInput, ListRegexPatternSetsCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListRegexPatternSetsCommandInput;
+    constructor(input: ListRegexPatternSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRegexPatternSetsCommandInput, ListRegexPatternSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListRuleGroupsCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListRuleGroupsRequest, ListRuleGroupsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListRuleGroupsCommandInput extends ListRuleGroupsRequest {
+}
+export interface ListRuleGroupsCommandOutput extends ListRuleGroupsResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *          <p>Returns an array of <a>RuleGroup</a> objects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListRuleGroupsCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListRuleGroupsCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListRuleGroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListRuleGroupsCommandInput} for command's `input` shape.
+ * @see {@link ListRuleGroupsCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListRuleGroupsCommand extends $Command<ListRuleGroupsCommandInput, ListRuleGroupsCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListRuleGroupsCommandInput;
+    constructor(input: ListRuleGroupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRuleGroupsCommandInput, ListRuleGroupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListRulesCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListRulesRequest, ListRulesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListRulesCommandInput extends ListRulesRequest {
+}
+export interface ListRulesCommandOutput extends ListRulesResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ * 		       <p>Returns an array of <a>RuleSummary</a> objects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListRulesCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListRulesCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListRulesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListRulesCommandInput} for command's `input` shape.
+ * @see {@link ListRulesCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListRulesCommand extends $Command<ListRulesCommandInput, ListRulesCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListRulesCommandInput;
+    constructor(input: ListRulesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRulesCommandInput, ListRulesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSizeConstraintSetsCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSizeConstraintSetsRequest, ListSizeConstraintSetsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListSizeConstraintSetsCommandInput extends ListSizeConstraintSetsRequest {
+}
+export interface ListSizeConstraintSetsCommandOutput extends ListSizeConstraintSetsResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ * 		       <p>Returns an array of <a>SizeConstraintSetSummary</a> objects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListSizeConstraintSetsCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListSizeConstraintSetsCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListSizeConstraintSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSizeConstraintSetsCommandInput} for command's `input` shape.
+ * @see {@link ListSizeConstraintSetsCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListSizeConstraintSetsCommand extends $Command<ListSizeConstraintSetsCommandInput, ListSizeConstraintSetsCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListSizeConstraintSetsCommandInput;
+    constructor(input: ListSizeConstraintSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSizeConstraintSetsCommandInput, ListSizeConstraintSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSqlInjectionMatchSetsCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSqlInjectionMatchSetsRequest, ListSqlInjectionMatchSetsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListSqlInjectionMatchSetsCommandInput extends ListSqlInjectionMatchSetsRequest {
+}
+export interface ListSqlInjectionMatchSetsCommandOutput extends ListSqlInjectionMatchSetsResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ * 		       <p>Returns an array of <a>SqlInjectionMatchSet</a> objects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListSqlInjectionMatchSetsCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListSqlInjectionMatchSetsCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListSqlInjectionMatchSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSqlInjectionMatchSetsCommandInput} for command's `input` shape.
+ * @see {@link ListSqlInjectionMatchSetsCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListSqlInjectionMatchSetsCommand extends $Command<ListSqlInjectionMatchSetsCommandInput, ListSqlInjectionMatchSetsCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListSqlInjectionMatchSetsCommandInput;
+    constructor(input: ListSqlInjectionMatchSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSqlInjectionMatchSetsCommandInput, ListSqlInjectionMatchSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSubscribedRuleGroupsCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSubscribedRuleGroupsRequest, ListSubscribedRuleGroupsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListSubscribedRuleGroupsCommandInput extends ListSubscribedRuleGroupsRequest {
+}
+export interface ListSubscribedRuleGroupsCommandOutput extends ListSubscribedRuleGroupsResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *          <p>Returns an array of <a>RuleGroup</a> objects that you are subscribed to.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListSubscribedRuleGroupsCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListSubscribedRuleGroupsCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListSubscribedRuleGroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSubscribedRuleGroupsCommandInput} for command's `input` shape.
+ * @see {@link ListSubscribedRuleGroupsCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListSubscribedRuleGroupsCommand extends $Command<ListSubscribedRuleGroupsCommandInput, ListSubscribedRuleGroupsCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListSubscribedRuleGroupsCommandInput;
+    constructor(input: ListSubscribedRuleGroupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSubscribedRuleGroupsCommandInput, ListSubscribedRuleGroupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *         <p>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.</p>
+ *         <p>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.  </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListTagsForResourceCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListTagsForResourceCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListWebACLsCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListWebACLsRequest, ListWebACLsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListWebACLsCommandInput extends ListWebACLsRequest {
+}
+export interface ListWebACLsCommandOutput extends ListWebACLsResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ * 		       <p>Returns an array of <a>WebACLSummary</a> objects in the response.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListWebACLsCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListWebACLsCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListWebACLsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListWebACLsCommandInput} for command's `input` shape.
+ * @see {@link ListWebACLsCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListWebACLsCommand extends $Command<ListWebACLsCommandInput, ListWebACLsCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListWebACLsCommandInput;
+    constructor(input: ListWebACLsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListWebACLsCommandInput, ListWebACLsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListXssMatchSetsCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListXssMatchSetsRequest, ListXssMatchSetsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface ListXssMatchSetsCommandInput extends ListXssMatchSetsRequest {
+}
+export interface ListXssMatchSetsCommandOutput extends ListXssMatchSetsResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ * 		       <p>Returns an array of <a>XssMatchSet</a> objects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, ListXssMatchSetsCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, ListXssMatchSetsCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new ListXssMatchSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListXssMatchSetsCommandInput} for command's `input` shape.
+ * @see {@link ListXssMatchSetsCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListXssMatchSetsCommand extends $Command<ListXssMatchSetsCommandInput, ListXssMatchSetsCommandOutput, WAFClientResolvedConfig> {
+    readonly input: ListXssMatchSetsCommandInput;
+    constructor(input: ListXssMatchSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListXssMatchSetsCommandInput, ListXssMatchSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutLoggingConfigurationCommand.d.ts

@@ -0,0 +1,60 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutLoggingConfigurationRequest, PutLoggingConfigurationResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface PutLoggingConfigurationCommandInput extends PutLoggingConfigurationRequest {
+}
+export interface PutLoggingConfigurationCommandOutput extends PutLoggingConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *          <p>Associates a <a>LoggingConfiguration</a> with a specified web ACL.</p>
+ * 	        <p>You can access information about all traffic that AWS WAF inspects using the following
+ *          steps:</p>
+ * 	        <ol>
+ *             <li>
+ *                <p>Create an Amazon Kinesis Data
+ *                Firehose. </p>
+ * 	              <p>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). </p>
+ * 	              <note>
+ *                   <p>Do not create the data firehose using a <code>Kinesis stream</code> as your source.</p>
+ *                </note>
+ *             </li>
+ *             <li>
+ *                <p>Associate that firehose to your web ACL using a <code>PutLoggingConfiguration</code> request.</p>
+ *             </li>
+ *          </ol>
+ *
+ *          <p>When you successfully enable logging using a <code>PutLoggingConfiguration</code> 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 <a href="https://docs.aws.amazon.com/waf/latest/developerguide/logging.html">Logging Web ACL Traffic Information</a> in the <i>AWS WAF Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, PutLoggingConfigurationCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, PutLoggingConfigurationCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new PutLoggingConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutLoggingConfigurationCommandInput} for command's `input` shape.
+ * @see {@link PutLoggingConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutLoggingConfigurationCommand extends $Command<PutLoggingConfigurationCommandInput, PutLoggingConfigurationCommandOutput, WAFClientResolvedConfig> {
+    readonly input: PutLoggingConfigurationCommandInput;
+    constructor(input: PutLoggingConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutLoggingConfigurationCommandInput, PutLoggingConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutPermissionPolicyCommand.d.ts

@@ -0,0 +1,75 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutPermissionPolicyRequest, PutPermissionPolicyResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface PutPermissionPolicyCommandInput extends PutPermissionPolicyRequest {
+}
+export interface PutPermissionPolicyCommandOutput extends PutPermissionPolicyResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *          <p>Attaches an IAM policy to the specified resource. The only supported use for this action is to share a RuleGroup across accounts.</p>
+ *          <p>The <code>PutPermissionPolicy</code> is subject to the following restrictions:</p>
+ *          <ul>
+ *             <li>
+ *                <p>You can attach only one policy with each <code>PutPermissionPolicy</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>The policy must include an <code>Effect</code>, <code>Action</code> and <code>Principal</code>. </p>
+ *             </li>
+ *             <li>
+ *
+ *                <p>
+ *                   <code>Effect</code> must specify <code>Allow</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>The <code>Action</code> in the policy must be <code>waf:UpdateWebACL</code>, <code>waf-regional:UpdateWebACL</code>, <code>waf:GetRuleGroup</code> and <code>waf-regional:GetRuleGroup</code> . Any extra or wildcard actions in the policy will be rejected.</p>
+ *             </li>
+ *             <li>
+ *                <p>The policy cannot include a <code>Resource</code> parameter.</p>
+ *             </li>
+ *             <li>
+ *                <p>The ARN in the request must be a valid WAF RuleGroup ARN and the RuleGroup must exist in the same region.</p>
+ *             </li>
+ *             <li>
+ *                <p>The user making the request must be the owner of the RuleGroup.</p>
+ *             </li>
+ *             <li>
+ *                <p>Your policy must be composed using IAM Policy version 2012-10-17.</p>
+ *             </li>
+ *          </ul>
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html">IAM Policies</a>.  </p>
+ *
+ *          <p>An example of a valid policy parameter is shown in the Examples section below.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, PutPermissionPolicyCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, PutPermissionPolicyCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new PutPermissionPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutPermissionPolicyCommandInput} for command's `input` shape.
+ * @see {@link PutPermissionPolicyCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PutPermissionPolicyCommand extends $Command<PutPermissionPolicyCommandInput, PutPermissionPolicyCommandOutput, WAFClientResolvedConfig> {
+    readonly input: PutPermissionPolicyCommandInput;
+    constructor(input: PutPermissionPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPermissionPolicyCommandInput, PutPermissionPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.d.ts

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *         <p>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.</p>
+ *         <p>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.  </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, TagResourceCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, TagResourceCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, WAFClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
+}
+/**
+ * <note>
+ *             <p>This is <b>AWS WAF Classic</b> documentation. For
+ *       more information, see <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS
+ *       WAF Classic</a> in the developer guide.</p>
+ *             <p>
+ *                <b>For the latest version of AWS
+ *       WAF</b>, use the AWS WAFV2 API and see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF Developer Guide</a>. With the latest version, AWS WAF has a single set of endpoints for regional and global use. </p>
+ *          </note>
+ *          <p></p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, UntagResourceCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, UntagResourceCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, WAFClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}