@aws-sdk/client-waf 3.32.0 → 3.36.0

package/dist-cjs/WAFClient.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAFClient = void 0;
+const config_resolver_1 = require("@aws-sdk/config-resolver");
+const middleware_content_length_1 = require("@aws-sdk/middleware-content-length");
+const middleware_host_header_1 = require("@aws-sdk/middleware-host-header");
+const middleware_logger_1 = require("@aws-sdk/middleware-logger");
+const middleware_retry_1 = require("@aws-sdk/middleware-retry");
+const middleware_signing_1 = require("@aws-sdk/middleware-signing");
+const middleware_user_agent_1 = require("@aws-sdk/middleware-user-agent");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const runtimeConfig_1 = require("./runtimeConfig");
+/**
+ * <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>This is the <i>AWS WAF Classic API Reference</i> for using AWS WAF Classic with Amazon CloudFront. The AWS WAF Classic actions and data types listed in the reference are available for protecting Amazon CloudFront distributions. You can use these actions and data types via the endpoint <i>waf.amazonaws.com</i>. This guide is for developers who need detailed information about the AWS WAF Classic API actions,
+ * 	      data types, and errors. For detailed information about AWS WAF Classic features and an overview of how to use the AWS WAF Classic API, see the
+ * 	      <a href="https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html">AWS WAF Classic</a> in the developer guide.</p>
+ */
+class WAFClient extends smithy_client_1.Client {
+    constructor(configuration) {
+        const _config_0 = runtimeConfig_1.getRuntimeConfig(configuration);
+        const _config_1 = config_resolver_1.resolveRegionConfig(_config_0);
+        const _config_2 = config_resolver_1.resolveEndpointsConfig(_config_1);
+        const _config_3 = middleware_retry_1.resolveRetryConfig(_config_2);
+        const _config_4 = middleware_host_header_1.resolveHostHeaderConfig(_config_3);
+        const _config_5 = middleware_signing_1.resolveAwsAuthConfig(_config_4);
+        const _config_6 = middleware_user_agent_1.resolveUserAgentConfig(_config_5);
+        super(_config_6);
+        this.config = _config_6;
+        this.middlewareStack.use(middleware_retry_1.getRetryPlugin(this.config));
+        this.middlewareStack.use(middleware_content_length_1.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middleware_host_header_1.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middleware_logger_1.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middleware_signing_1.getAwsAuthPlugin(this.config));
+        this.middlewareStack.use(middleware_user_agent_1.getUserAgentPlugin(this.config));
+    }
+    /**
+     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+     */
+    destroy() {
+        super.destroy();
+    }
+}
+exports.WAFClient = WAFClient;

package/dist-cjs/commands/CreateByteMatchSetCommand.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateByteMatchSetCommand = 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>ByteMatchSet</code>. You then use <a>UpdateByteMatchSet</a> to identify the part of a
+ * 			web request that you want AWS WAF to inspect, such as the values of the <code>User-Agent</code> header or the query string.
+ * 			For example, you can create a <code>ByteMatchSet</code> that matches any requests with <code>User-Agent</code> headers
+ * 			that contain the string <code>BadBot</code>. You can then configure AWS WAF to reject those requests.</p>
+ * 		       <p>To create and configure a <code>ByteMatchSet</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>CreateByteMatchSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateByteMatchSet</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>UpdateByteMatchSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <a>UpdateByteMatchSet</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, CreateByteMatchSetCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateByteMatchSetCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateByteMatchSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateByteMatchSetCommandInput} for command's `input` shape.
+ * @see {@link CreateByteMatchSetCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateByteMatchSetCommand 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 = "CreateByteMatchSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateByteMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateByteMatchSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateByteMatchSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateByteMatchSetCommand(output, context);
+    }
+}
+exports.CreateByteMatchSetCommand = CreateByteMatchSetCommand;

package/dist-cjs/commands/CreateGeoMatchSetCommand.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateGeoMatchSetCommand = 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 an <a>GeoMatchSet</a>, which you use to specify which web requests you want to allow or block based on the country
+ * 			that the requests originate from. For example, if you're receiving a lot of requests from one or more countries and you want to block the requests, you can create an <code>GeoMatchSet</code> that contains those countries and then configure AWS WAF to block the requests. </p>
+ * 		       <p>To create and configure a <code>GeoMatchSet</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>CreateGeoMatchSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateGeoMatchSet</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>UpdateGeoMatchSet</a> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <code>UpdateGeoMatchSetSet</code> request to specify the countries 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, CreateGeoMatchSetCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateGeoMatchSetCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateGeoMatchSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateGeoMatchSetCommandInput} for command's `input` shape.
+ * @see {@link CreateGeoMatchSetCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateGeoMatchSetCommand 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 = "CreateGeoMatchSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateGeoMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateGeoMatchSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateGeoMatchSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateGeoMatchSetCommand(output, context);
+    }
+}
+exports.CreateGeoMatchSetCommand = CreateGeoMatchSetCommand;

package/dist-cjs/commands/CreateIPSetCommand.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateIPSetCommand = 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 an <a>IPSet</a>, which you use to specify which web requests
+ *          that
+ *          you want to allow or block based on the IP addresses that the requests
+ *          originate from. For example, if you're receiving a lot of requests from one or more
+ *          individual IP addresses or one or more ranges of IP addresses and you want to block the
+ *          requests, you can create an <code>IPSet</code> that contains those IP addresses and then
+ *          configure AWS WAF to block the requests. </p>
+ * 		       <p>To create and configure an <code>IPSet</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>CreateIPSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateIPSet</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>UpdateIPSet</a> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <code>UpdateIPSet</code> request to specify the IP addresses 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, CreateIPSetCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateIPSetCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateIPSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateIPSetCommandInput} for command's `input` shape.
+ * @see {@link CreateIPSetCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateIPSetCommand 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 = "CreateIPSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateIPSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateIPSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateIPSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateIPSetCommand(output, context);
+    }
+}
+exports.CreateIPSetCommand = CreateIPSetCommand;

package/dist-cjs/commands/CreateRateBasedRuleCommand.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRateBasedRuleCommand = 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>RateBasedRule</a>. The <code>RateBasedRule</code> contains a
+ *             <code>RateLimit</code>, which specifies the maximum number of requests that AWS WAF allows
+ *                 from a specified IP address in a five-minute period.
+ *                 The <code>RateBasedRule</code> also
+ *          contains the <code>IPSet</code> objects, <code>ByteMatchSet</code> objects, and other
+ *          predicates that identify the requests that you want to count or block if these requests
+ *          exceed the <code>RateLimit</code>.</p>
+ *          <p>If you add more than one predicate to a <code>RateBasedRule</code>, a request not
+ *          only must exceed the <code>RateLimit</code>, but it also must match all the
+ *          conditions to be counted or blocked. For example, suppose you add the following to a
+ *             <code>RateBasedRule</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>Further, you specify a <code>RateLimit</code> of 1,000.</p>
+ *          <p>You then add the <code>RateBasedRule</code> to a <code>WebACL</code> and specify that
+ *          you want to block requests that meet the conditions in the rule. For a request to be
+ *          blocked, it must come from the IP address 192.0.2.44 <i>and</i> the
+ *             <code>User-Agent</code> header in the request must contain the value
+ *          <code>BadBot</code>. Further, requests that match these two conditions must be received at
+ *          a rate of more than 1,000 requests every five minutes. If both conditions are met and the
+ *          rate is exceeded, AWS WAF blocks the requests. If the rate drops below 1,000 for a
+ *          five-minute period, AWS WAF no longer blocks the requests.</p>
+ *
+ * 		       <p>As a second example, suppose you want to limit requests to a particular page on your site. To do this, you could add the following to a
+ *             <code>RateBasedRule</code>:</p>
+ *
+ *
+ *          <ul>
+ *             <li>
+ *                <p>A <code>ByteMatchSet</code> with <code>FieldToMatch</code> of <code>URI</code>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>A <code>PositionalConstraint</code> of <code>STARTS_WITH</code>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                <p>A <code>TargetString</code> of <code>login</code>
+ *                </p>
+ *             </li>
+ *          </ul>
+ *          <p>Further, you specify a <code>RateLimit</code> of 1,000.</p>
+ *          <p>By adding this <code>RateBasedRule</code> to a <code>WebACL</code>, you could limit requests to your login page without affecting the rest of your site.</p>
+ *
+ *
+ *          <p>To create and configure a <code>RateBasedRule</code>, perform the following
+ *          steps:</p>
+ *          <ol>
+ *             <li>
+ *                <p>Create and update the predicates that you want to include in the rule. 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>CreateRateBasedRule</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>UpdateRateBasedRule</code> request to specify the predicates
+ *                that you want to include in the rule.</p>
+ *             </li>
+ *             <li>
+ *                <p>Create and update a <code>WebACL</code> that contains the
+ *                   <code>RateBasedRule</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, CreateRateBasedRuleCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateRateBasedRuleCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateRateBasedRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRateBasedRuleCommandInput} for command's `input` shape.
+ * @see {@link CreateRateBasedRuleCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateRateBasedRuleCommand 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 = "CreateRateBasedRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateRateBasedRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateRateBasedRuleResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateRateBasedRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateRateBasedRuleCommand(output, context);
+    }
+}
+exports.CreateRateBasedRuleCommand = CreateRateBasedRuleCommand;

package/dist-cjs/commands/CreateRegexMatchSetCommand.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRegexMatchSetCommand = 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>RegexMatchSet</a>. You then use <a>UpdateRegexMatchSet</a> to identify the part of a
+ *          web request that you want AWS WAF to inspect, such as the values of the <code>User-Agent</code> header or the query string.
+ *          For example, you can create a <code>RegexMatchSet</code> that contains a <code>RegexMatchTuple</code> that looks for any requests with <code>User-Agent</code> headers
+ *          that match a <code>RegexPatternSet</code> with pattern <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>RegexMatchSet</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>CreateRegexMatchSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit a <code>CreateRegexMatchSet</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>UpdateRegexMatchSet</code> request.</p>
+ *             </li>
+ *             <li>
+ *                <p>Submit an <a>UpdateRegexMatchSet</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, using a <code>RegexPatternSet</code>, 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, CreateRegexMatchSetCommand } from "@aws-sdk/client-waf"; // ES Modules import
+ * // const { WAFClient, CreateRegexMatchSetCommand } = require("@aws-sdk/client-waf"); // CommonJS import
+ * const client = new WAFClient(config);
+ * const command = new CreateRegexMatchSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRegexMatchSetCommandInput} for command's `input` shape.
+ * @see {@link CreateRegexMatchSetCommandOutput} for command's `response` shape.
+ * @see {@link WAFClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateRegexMatchSetCommand 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 = "CreateRegexMatchSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateRegexMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateRegexMatchSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_json1_1_1.serializeAws_json1_1CreateRegexMatchSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_json1_1_1.deserializeAws_json1_1CreateRegexMatchSetCommand(output, context);
+    }
+}
+exports.CreateRegexMatchSetCommand = CreateRegexMatchSetCommand;