@aws-sdk/client-waf 3.32.0 → 3.36.0

package/dist-cjs/commands/CreateRegexPatternSetCommand.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRegexPatternSetCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <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>Creates a <code>RegexPatternSet</code>. You then use <a>UpdateRegexPatternSet</a> to specify the regular expression (regex) pattern that you want AWS WAF to search for, such as <code>B[a@]dB[o0]t</code>. You can then configure AWS WAF to reject those requests.</p>
+ * 		       <p>To create and configure a <code>RegexPatternSet</code>, perform the following steps:</p>
+ *          <ol>
+ *             <li>
+ *                <p>Use <a>GetChangeToken</a> to get the change token that you provide in the <code>ChangeToken</code> parameter of a
+ *                   <code>CreateRegexPatternSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateRegexPatternSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <code>GetChangeToken</code> to get the change token that you provide in the <code>ChangeToken</code> parameter of an
+ *                   <code>UpdateRegexPatternSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <a>UpdateRegexPatternSet</a> request to specify the string that you want AWS WAF to watch for.</p>
+ *             </li>
+ *          </ol>
+ *          <p>For more information about how to use the AWS WAF API to allow or block HTTP requests, see the
+ *             <a href="https://docs.aws.amazon.com/waf/latest/developerguide/">AWS WAF Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, CreateRegexPatternSetCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateRegexPatternSetCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateRegexPatternSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRegexPatternSetCommandInput} for command's `input` shape.
+ * @see {@link CreateRegexPatternSetCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateRegexPatternSetCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "WAFClient";
+        const commandName = "CreateRegexPatternSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateRegexPatternSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateRegexPatternSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateRegexPatternSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateRegexPatternSetCommand(output, context);
+    }
+}
+exports.CreateRegexPatternSetCommand = CreateRegexPatternSetCommand;

package/dist-cjs/commands/CreateRuleCommand.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRuleCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <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>Creates a <code>Rule</code>, which contains the <code>IPSet</code> objects,
+ *             <code>ByteMatchSet</code> objects, and other predicates that identify the requests that
+ *          you want to block. If you add more than one predicate to a <code>Rule</code>, a request
+ *          must match all of the specifications to be allowed or blocked. For example, suppose
+ *          that
+ *          you add the following to a <code>Rule</code>:</p>
+ * 		       <ul>
+ *             <li>
+ *                <p>An <code>IPSet</code> that matches the IP address <code>192.0.2.44/32</code>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>A <code>ByteMatchSet</code> that matches <code>BadBot</code> in the <code>User-Agent</code> header</p>
+ *             </li>
+ *          </ul>
+ * 		       <p>You then add the <code>Rule</code> to a <code>WebACL</code> and specify that you want to blocks requests that satisfy the <code>Rule</code>.
+ * 			For a request to be blocked, it must come from the IP address 192.0.2.44 <i>and</i> the <code>User-Agent</code> header in the request
+ * 			must contain the value <code>BadBot</code>.</p>
+ * 		       <p>To create and configure a <code>Rule</code>, perform the following steps:</p>
+ * 		       <ol>
+ *             <li>
+ *                <p>Create and update the predicates that you want to include in the <code>Rule</code>. For more information, see
+ * 				<a>CreateByteMatchSet</a>, <a>CreateIPSet</a>, and <a>CreateSqlInjectionMatchSet</a>.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <a>GetChangeToken</a> to get the change token that you provide in the <code>ChangeToken</code> parameter of a
+ * 				<code>CreateRule</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateRule</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <code>GetChangeToken</code> to get the change token that you provide in the <code>ChangeToken</code> parameter of an
+ * 				<a>UpdateRule</a> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <code>UpdateRule</code> request to specify the predicates that you want to include in the <code>Rule</code>.</p>
+ *             </li>
+ *             <li>
+ *                <p>Create and update a <code>WebACL</code> that contains the <code>Rule</code>. For more information, see <a>CreateWebACL</a>.</p>
+ *             </li>
+ *          </ol>
+ * 		       <p>For more information about how to use the AWS WAF API to allow or block HTTP requests, see the
+ * 			<a href="https://docs.aws.amazon.com/waf/latest/developerguide/">AWS WAF Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, CreateRuleCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateRuleCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRuleCommandInput} for command's `input` shape.
+ * @see {@link CreateRuleCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateRuleCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "WAFClient";
+        const commandName = "CreateRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateRuleResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateRuleCommand(output, context);
+    }
+}
+exports.CreateRuleCommand = CreateRuleCommand;

package/dist-cjs/commands/CreateRuleGroupCommand.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRuleGroupCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <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>Creates a <code>RuleGroup</code>. A rule group is a collection of predefined rules that you add to a web ACL. You use <a>UpdateRuleGroup</a> to add rules to the rule group.</p>
+ * 	        <p>Rule groups are subject to the following limits:</p>
+ * 	        <ul>
+ *             <li>
+ *                <p>Three rule groups per account. You can request an increase to this limit by contacting customer support.</p>
+ *             </li>
+ *             <li>
+ *                <p>One rule group per web ACL.</p>
+ *             </li>
+ *             <li>
+ *                <p>Ten rules per rule group.</p>
+ *             </li>
+ *          </ul>
+ *          <p>For more information about how to use the AWS WAF API to allow or block HTTP requests, see the
+ *          <a href="https://docs.aws.amazon.com/waf/latest/developerguide/">AWS WAF Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, CreateRuleGroupCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateRuleGroupCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateRuleGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRuleGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateRuleGroupCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateRuleGroupCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "WAFClient";
+        const commandName = "CreateRuleGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateRuleGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateRuleGroupResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateRuleGroupCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateRuleGroupCommand(output, context);
+    }
+}
+exports.CreateRuleGroupCommand = CreateRuleGroupCommand;

package/dist-cjs/commands/CreateSizeConstraintSetCommand.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSizeConstraintSetCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <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>Creates a <code>SizeConstraintSet</code>. You then use <a>UpdateSizeConstraintSet</a> to identify the part of a
+ * 			web request that you want AWS WAF to check for length, such as the length of the <code>User-Agent</code> header or the length of the query string.
+ * 			For example, you can create a <code>SizeConstraintSet</code> that matches any requests that have a query string that is longer than 100 bytes.
+ * 			You can then configure AWS WAF to reject those requests.</p>
+ * 		       <p>To create and configure a <code>SizeConstraintSet</code>, perform the following steps:</p>
+ * 		       <ol>
+ *             <li>
+ *                <p>Use <a>GetChangeToken</a> to get the change token that you provide in the <code>ChangeToken</code> parameter of a
+ * 				<code>CreateSizeConstraintSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateSizeConstraintSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <code>GetChangeToken</code> to get the change token that you provide in the <code>ChangeToken</code> parameter of an
+ * 				<code>UpdateSizeConstraintSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <a>UpdateSizeConstraintSet</a> request to specify the part of the request that you want AWS WAF to inspect
+ * 				(for example, the header or the URI) and the value that you want AWS WAF to watch for.</p>
+ *             </li>
+ *          </ol>
+ * 		       <p>For more information about how to use the AWS WAF API to allow or block HTTP requests, see the
+ * 			<a href="https://docs.aws.amazon.com/waf/latest/developerguide/">AWS WAF Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, CreateSizeConstraintSetCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateSizeConstraintSetCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateSizeConstraintSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSizeConstraintSetCommandInput} for command's `input` shape.
+ * @see {@link CreateSizeConstraintSetCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateSizeConstraintSetCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "WAFClient";
+        const commandName = "CreateSizeConstraintSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateSizeConstraintSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateSizeConstraintSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateSizeConstraintSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateSizeConstraintSetCommand(output, context);
+    }
+}
+exports.CreateSizeConstraintSetCommand = CreateSizeConstraintSetCommand;

package/dist-cjs/commands/CreateSqlInjectionMatchSetCommand.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSqlInjectionMatchSetCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <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>Creates a <a>SqlInjectionMatchSet</a>, which you use to allow, block, or count requests that contain snippets of SQL code in a
+ * 			specified part of web requests. AWS WAF searches for character sequences that are likely to be malicious strings.</p>
+ * 		       <p>To create and configure a <code>SqlInjectionMatchSet</code>, perform the following steps:</p>
+ * 		       <ol>
+ *             <li>
+ *                <p>Use <a>GetChangeToken</a> to get the change token that you provide in the <code>ChangeToken</code> parameter of a
+ * 				<code>CreateSqlInjectionMatchSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateSqlInjectionMatchSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <code>GetChangeToken</code> to get the change token that you provide in the <code>ChangeToken</code> parameter of an
+ * 				<a>UpdateSqlInjectionMatchSet</a> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <a>UpdateSqlInjectionMatchSet</a> request to specify the parts of web requests in which you want to
+ * 				allow, block, or count malicious SQL code.</p>
+ *             </li>
+ *          </ol>
+ * 		       <p>For more information about how to use the AWS WAF API to allow or block HTTP requests, see the
+ * 			<a href="https://docs.aws.amazon.com/waf/latest/developerguide/">AWS WAF Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, CreateSqlInjectionMatchSetCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateSqlInjectionMatchSetCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateSqlInjectionMatchSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSqlInjectionMatchSetCommandInput} for command's `input` shape.
+ * @see {@link CreateSqlInjectionMatchSetCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateSqlInjectionMatchSetCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "WAFClient";
+        const commandName = "CreateSqlInjectionMatchSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateSqlInjectionMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateSqlInjectionMatchSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateSqlInjectionMatchSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateSqlInjectionMatchSetCommand(output, context);
+    }
+}
+exports.CreateSqlInjectionMatchSetCommand = CreateSqlInjectionMatchSetCommand;

package/dist-cjs/commands/CreateWebACLCommand.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateWebACLCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <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>Creates a <code>WebACL</code>, which contains the <code>Rules</code> that identify the CloudFront web requests that you want to allow, block, or count.
+ * 			AWS WAF evaluates <code>Rules</code> in order based on the value of <code>Priority</code> for each <code>Rule</code>.</p>
+ * 		       <p>You also specify a default action, either <code>ALLOW</code> or <code>BLOCK</code>. If a web request doesn't match
+ * 			any of the <code>Rules</code> in a <code>WebACL</code>, AWS WAF responds to the request with the default action. </p>
+ * 		       <p>To create and configure a <code>WebACL</code>, perform the following steps:</p>
+ * 		       <ol>
+ *             <li>
+ *                <p>Create and update the <code>ByteMatchSet</code> objects and other predicates that you want to include in <code>Rules</code>.
+ * 				For more information, see <a>CreateByteMatchSet</a>, <a>UpdateByteMatchSet</a>, <a>CreateIPSet</a>, <a>UpdateIPSet</a>,
+ * 				<a>CreateSqlInjectionMatchSet</a>, and <a>UpdateSqlInjectionMatchSet</a>.</p>
+ *             </li>
+ *             <li>
+ *                <p>Create and update the <code>Rules</code> that you want to include in the <code>WebACL</code>. For more information, see
+ * 				<a>CreateRule</a> and <a>UpdateRule</a>.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <a>GetChangeToken</a> to get the change token that you provide in the <code>ChangeToken</code> parameter of a
+ * 				<code>CreateWebACL</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateWebACL</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Use <code>GetChangeToken</code> to get the change token that you provide in the <code>ChangeToken</code> parameter of an
+ * 				<a>UpdateWebACL</a> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <a>UpdateWebACL</a> request to specify the <code>Rules</code> that you want to include in the <code>WebACL</code>,
+ * 				to specify the default action, and to associate the <code>WebACL</code> with a CloudFront distribution.</p>
+ *             </li>
+ *          </ol>
+ * 		       <p>For more information about how to use the AWS WAF API, see the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/">AWS WAF Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, CreateWebACLCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateWebACLCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateWebACLCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateWebACLCommandInput} for command's `input` shape.
+ * @see {@link CreateWebACLCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateWebACLCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "WAFClient";
+        const commandName = "CreateWebACLCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateWebACLRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateWebACLResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateWebACLCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateWebACLCommand(output, context);
+    }
+}
+exports.CreateWebACLCommand = CreateWebACLCommand;

package/dist-cjs/commands/CreateWebACLMigrationStackCommand.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateWebACLMigrationStackCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_json1_1_1 = require("../protocols/Aws_json1_1");
+/**
+ * <p>Creates an AWS CloudFormation WAFV2 template for the specified web ACL in the specified Amazon S3 bucket.
+ *            Then, in CloudFormation, you create a stack from the template, to create the web ACL and its resources in AWS WAFV2.
+ *            Use this to migrate your AWS WAF Classic web ACL to the latest version of AWS WAF.</p>
+ *          <p>This is part of a larger migration procedure for web ACLs from AWS WAF Classic to the latest version of AWS WAF.
+ *            For the full procedure, including caveats and manual steps to complete
+ *            the migration and switch over to the new web ACL, see
+ *            <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-migrating-from-classic.html">Migrating your AWS WAF Classic resources to AWS WAF</a> in the <a href="https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html">AWS WAF
+ *   Developer Guide</a>.  </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { WAFClient, CreateWebACLMigrationStackCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateWebACLMigrationStackCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateWebACLMigrationStackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateWebACLMigrationStackCommandInput} for command's `input` shape.
+ * @see {@link CreateWebACLMigrationStackCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateWebACLMigrationStackCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "WAFClient";
+        const commandName = "CreateWebACLMigrationStackCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateWebACLMigrationStackRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateWebACLMigrationStackResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateWebACLMigrationStackCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateWebACLMigrationStackCommand(output, context);
+    }
+}
+exports.CreateWebACLMigrationStackCommand = CreateWebACLMigrationStackCommand;