@aws-sdk/client-waf 3.35.0 → 3.38.0

package/dist-types/ts3.4/commands/GetSqlInjectionMatchSetCommand.d.ts

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

package/dist-types/ts3.4/commands/GetWebACLCommand.d.ts

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

package/dist-types/ts3.4/commands/GetXssMatchSetCommand.d.ts

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

package/dist-types/ts3.4/commands/ListActivatedRulesInRuleGroupCommand.d.ts

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

package/dist-types/ts3.4/commands/ListByteMatchSetsCommand.d.ts

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

package/dist-types/ts3.4/commands/ListGeoMatchSetsCommand.d.ts

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

package/dist-types/ts3.4/commands/ListIPSetsCommand.d.ts

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

package/dist-types/ts3.4/commands/ListLoggingConfigurationsCommand.d.ts

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

package/dist-types/ts3.4/commands/ListRateBasedRulesCommand.d.ts

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

package/dist-types/ts3.4/commands/ListRegexMatchSetsCommand.d.ts

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

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

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

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

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

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

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

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

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

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

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