@aws-sdk/client-waf 3.34.0 → 3.35.0

package/src/commands/CreateRegexMatchSetCommand.ts

@@ -0,0 +1,126 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CreateRegexMatchSetRequest, CreateRegexMatchSetResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateRegexMatchSetCommand,
+  serializeAws_json1_1CreateRegexMatchSetCommand,
+} from "../protocols/Aws_json1_1";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+
+export interface CreateRegexMatchSetCommandInput extends CreateRegexMatchSetRequest {}
+export interface CreateRegexMatchSetCommandOutput extends CreateRegexMatchSetResponse, __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>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.
+ *
+ */
+export class CreateRegexMatchSetCommand extends $Command<
+  CreateRegexMatchSetCommandInput,
+  CreateRegexMatchSetCommandOutput,
+  WAFClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateRegexMatchSetCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: WAFClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateRegexMatchSetCommandInput, CreateRegexMatchSetCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "WAFClient";
+    const commandName = "CreateRegexMatchSetCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateRegexMatchSetRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateRegexMatchSetResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateRegexMatchSetCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateRegexMatchSetCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateRegexMatchSetCommandOutput> {
+    return deserializeAws_json1_1CreateRegexMatchSetCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateRegexPatternSetCommand.ts

@@ -0,0 +1,122 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CreateRegexPatternSetRequest, CreateRegexPatternSetResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateRegexPatternSetCommand,
+  serializeAws_json1_1CreateRegexPatternSetCommand,
+} from "../protocols/Aws_json1_1";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+
+export interface CreateRegexPatternSetCommandInput extends CreateRegexPatternSetRequest {}
+export interface CreateRegexPatternSetCommandOutput extends CreateRegexPatternSetResponse, __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>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.
+ *
+ */
+export class CreateRegexPatternSetCommand extends $Command<
+  CreateRegexPatternSetCommandInput,
+  CreateRegexPatternSetCommandOutput,
+  WAFClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateRegexPatternSetCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: WAFClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateRegexPatternSetCommandInput, CreateRegexPatternSetCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "WAFClient";
+    const commandName = "CreateRegexPatternSetCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateRegexPatternSetRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateRegexPatternSetResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateRegexPatternSetCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateRegexPatternSetCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateRegexPatternSetCommandOutput> {
+    return deserializeAws_json1_1CreateRegexPatternSetCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateRuleCommand.ts

@@ -0,0 +1,146 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CreateRuleRequest, CreateRuleResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateRuleCommand,
+  serializeAws_json1_1CreateRuleCommand,
+} from "../protocols/Aws_json1_1";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+
+export interface CreateRuleCommandInput extends CreateRuleRequest {}
+export interface CreateRuleCommandOutput extends CreateRuleResponse, __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>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.
+ *
+ */
+export class CreateRuleCommand extends $Command<
+  CreateRuleCommandInput,
+  CreateRuleCommandOutput,
+  WAFClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateRuleCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: WAFClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateRuleCommandInput, CreateRuleCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "WAFClient";
+    const commandName = "CreateRuleCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateRuleRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateRuleResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateRuleCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateRuleCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateRuleCommandOutput> {
+    return deserializeAws_json1_1CreateRuleCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateRuleGroupCommand.ts

@@ -0,0 +1,117 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CreateRuleGroupRequest, CreateRuleGroupResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateRuleGroupCommand,
+  serializeAws_json1_1CreateRuleGroupCommand,
+} from "../protocols/Aws_json1_1";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+
+export interface CreateRuleGroupCommandInput extends CreateRuleGroupRequest {}
+export interface CreateRuleGroupCommandOutput extends CreateRuleGroupResponse, __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>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.
+ *
+ */
+export class CreateRuleGroupCommand extends $Command<
+  CreateRuleGroupCommandInput,
+  CreateRuleGroupCommandOutput,
+  WAFClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateRuleGroupCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: WAFClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateRuleGroupCommandInput, CreateRuleGroupCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "WAFClient";
+    const commandName = "CreateRuleGroupCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateRuleGroupRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateRuleGroupResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateRuleGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateRuleGroupCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateRuleGroupCommandOutput> {
+    return deserializeAws_json1_1CreateRuleGroupCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/CreateSizeConstraintSetCommand.ts

@@ -0,0 +1,126 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { CreateSizeConstraintSetRequest, CreateSizeConstraintSetResponse } from "../models/models_0";
+import {
+  deserializeAws_json1_1CreateSizeConstraintSetCommand,
+  serializeAws_json1_1CreateSizeConstraintSetCommand,
+} from "../protocols/Aws_json1_1";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+
+export interface CreateSizeConstraintSetCommandInput extends CreateSizeConstraintSetRequest {}
+export interface CreateSizeConstraintSetCommandOutput extends CreateSizeConstraintSetResponse, __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>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.
+ *
+ */
+export class CreateSizeConstraintSetCommand extends $Command<
+  CreateSizeConstraintSetCommandInput,
+  CreateSizeConstraintSetCommandOutput,
+  WAFClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: CreateSizeConstraintSetCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: WAFClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<CreateSizeConstraintSetCommandInput, CreateSizeConstraintSetCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "WAFClient";
+    const commandName = "CreateSizeConstraintSetCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: CreateSizeConstraintSetRequest.filterSensitiveLog,
+      outputFilterSensitiveLog: CreateSizeConstraintSetResponse.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: CreateSizeConstraintSetCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_json1_1CreateSizeConstraintSetCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateSizeConstraintSetCommandOutput> {
+    return deserializeAws_json1_1CreateSizeConstraintSetCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}