@aws-sdk/client-waf 3.50.0 → 3.51.0

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateGeoMatchSetRequest, CreateGeoMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateGeoMatchSetCommandInput extends CreateGeoMatchSetRequest {
+}
+export interface CreateGeoMatchSetCommandOutput extends CreateGeoMatchSetResponse, __MetadataBearer {
+}
+
+export declare class CreateGeoMatchSetCommand extends $Command<CreateGeoMatchSetCommandInput, CreateGeoMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateGeoMatchSetCommandInput;
+    constructor(input: CreateGeoMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGeoMatchSetCommandInput, CreateGeoMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateIPSetRequest, CreateIPSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateIPSetCommandInput extends CreateIPSetRequest {
+}
+export interface CreateIPSetCommandOutput extends CreateIPSetResponse, __MetadataBearer {
+}
+
+export declare class CreateIPSetCommand extends $Command<CreateIPSetCommandInput, CreateIPSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateIPSetCommandInput;
+    constructor(input: CreateIPSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIPSetCommandInput, CreateIPSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateRateBasedRuleRequest, CreateRateBasedRuleResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateRateBasedRuleCommandInput extends CreateRateBasedRuleRequest {
+}
+export interface CreateRateBasedRuleCommandOutput extends CreateRateBasedRuleResponse, __MetadataBearer {
+}
+
+export declare class CreateRateBasedRuleCommand extends $Command<CreateRateBasedRuleCommandInput, CreateRateBasedRuleCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateRateBasedRuleCommandInput;
+    constructor(input: CreateRateBasedRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRateBasedRuleCommandInput, CreateRateBasedRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateRegexMatchSetRequest, CreateRegexMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateRegexMatchSetCommandInput extends CreateRegexMatchSetRequest {
+}
+export interface CreateRegexMatchSetCommandOutput extends CreateRegexMatchSetResponse, __MetadataBearer {
+}
+
+export declare class CreateRegexMatchSetCommand extends $Command<CreateRegexMatchSetCommandInput, CreateRegexMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateRegexMatchSetCommandInput;
+    constructor(input: CreateRegexMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRegexMatchSetCommandInput, CreateRegexMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateRegexPatternSetRequest, CreateRegexPatternSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateRegexPatternSetCommandInput extends CreateRegexPatternSetRequest {
+}
+export interface CreateRegexPatternSetCommandOutput extends CreateRegexPatternSetResponse, __MetadataBearer {
+}
+
+export declare class CreateRegexPatternSetCommand extends $Command<CreateRegexPatternSetCommandInput, CreateRegexPatternSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateRegexPatternSetCommandInput;
+    constructor(input: CreateRegexPatternSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRegexPatternSetCommandInput, CreateRegexPatternSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateRuleRequest, CreateRuleResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateRuleCommandInput extends CreateRuleRequest {
+}
+export interface CreateRuleCommandOutput extends CreateRuleResponse, __MetadataBearer {
+}
+
+export declare class CreateRuleCommand extends $Command<CreateRuleCommandInput, CreateRuleCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateRuleCommandInput;
+    constructor(input: CreateRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRuleCommandInput, CreateRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateRuleGroupRequest, CreateRuleGroupResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateRuleGroupCommandInput extends CreateRuleGroupRequest {
+}
+export interface CreateRuleGroupCommandOutput extends CreateRuleGroupResponse, __MetadataBearer {
+}
+
+export declare class CreateRuleGroupCommand extends $Command<CreateRuleGroupCommandInput, CreateRuleGroupCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateRuleGroupCommandInput;
+    constructor(input: CreateRuleGroupCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRuleGroupCommandInput, CreateRuleGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateSizeConstraintSetRequest, CreateSizeConstraintSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateSizeConstraintSetCommandInput extends CreateSizeConstraintSetRequest {
+}
+export interface CreateSizeConstraintSetCommandOutput extends CreateSizeConstraintSetResponse, __MetadataBearer {
+}
+
+export declare class CreateSizeConstraintSetCommand extends $Command<CreateSizeConstraintSetCommandInput, CreateSizeConstraintSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateSizeConstraintSetCommandInput;
+    constructor(input: CreateSizeConstraintSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSizeConstraintSetCommandInput, CreateSizeConstraintSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateSqlInjectionMatchSetRequest, CreateSqlInjectionMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateSqlInjectionMatchSetCommandInput extends CreateSqlInjectionMatchSetRequest {
+}
+export interface CreateSqlInjectionMatchSetCommandOutput extends CreateSqlInjectionMatchSetResponse, __MetadataBearer {
+}
+
+export declare class CreateSqlInjectionMatchSetCommand extends $Command<CreateSqlInjectionMatchSetCommandInput, CreateSqlInjectionMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateSqlInjectionMatchSetCommandInput;
+    constructor(input: CreateSqlInjectionMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSqlInjectionMatchSetCommandInput, CreateSqlInjectionMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateWebACLRequest, CreateWebACLResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateWebACLCommandInput extends CreateWebACLRequest {
+}
+export interface CreateWebACLCommandOutput extends CreateWebACLResponse, __MetadataBearer {
+}
+
+export declare class CreateWebACLCommand extends $Command<CreateWebACLCommandInput, CreateWebACLCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateWebACLCommandInput;
+    constructor(input: CreateWebACLCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWebACLCommandInput, CreateWebACLCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateWebACLMigrationStackRequest, CreateWebACLMigrationStackResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateWebACLMigrationStackCommandInput extends CreateWebACLMigrationStackRequest {
+}
+export interface CreateWebACLMigrationStackCommandOutput extends CreateWebACLMigrationStackResponse, __MetadataBearer {
+}
+
+export declare class CreateWebACLMigrationStackCommand extends $Command<CreateWebACLMigrationStackCommandInput, CreateWebACLMigrationStackCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateWebACLMigrationStackCommandInput;
+    constructor(input: CreateWebACLMigrationStackCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWebACLMigrationStackCommandInput, CreateWebACLMigrationStackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateXssMatchSetRequest, CreateXssMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface CreateXssMatchSetCommandInput extends CreateXssMatchSetRequest {
+}
+export interface CreateXssMatchSetCommandOutput extends CreateXssMatchSetResponse, __MetadataBearer {
+}
+
+export declare class CreateXssMatchSetCommand extends $Command<CreateXssMatchSetCommandInput, CreateXssMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: CreateXssMatchSetCommandInput;
+    constructor(input: CreateXssMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateXssMatchSetCommandInput, CreateXssMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteByteMatchSetRequest, DeleteByteMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteByteMatchSetCommandInput extends DeleteByteMatchSetRequest {
+}
+export interface DeleteByteMatchSetCommandOutput extends DeleteByteMatchSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteByteMatchSetCommand extends $Command<DeleteByteMatchSetCommandInput, DeleteByteMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteByteMatchSetCommandInput;
+    constructor(input: DeleteByteMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteByteMatchSetCommandInput, DeleteByteMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteGeoMatchSetRequest, DeleteGeoMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteGeoMatchSetCommandInput extends DeleteGeoMatchSetRequest {
+}
+export interface DeleteGeoMatchSetCommandOutput extends DeleteGeoMatchSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteGeoMatchSetCommand extends $Command<DeleteGeoMatchSetCommandInput, DeleteGeoMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteGeoMatchSetCommandInput;
+    constructor(input: DeleteGeoMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteGeoMatchSetCommandInput, DeleteGeoMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteIPSetRequest, DeleteIPSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteIPSetCommandInput extends DeleteIPSetRequest {
+}
+export interface DeleteIPSetCommandOutput extends DeleteIPSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteIPSetCommand extends $Command<DeleteIPSetCommandInput, DeleteIPSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteIPSetCommandInput;
+    constructor(input: DeleteIPSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIPSetCommandInput, DeleteIPSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteLoggingConfigurationRequest, DeleteLoggingConfigurationResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteLoggingConfigurationCommandInput extends DeleteLoggingConfigurationRequest {
+}
+export interface DeleteLoggingConfigurationCommandOutput extends DeleteLoggingConfigurationResponse, __MetadataBearer {
+}
+
+export declare class DeleteLoggingConfigurationCommand extends $Command<DeleteLoggingConfigurationCommandInput, DeleteLoggingConfigurationCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteLoggingConfigurationCommandInput;
+    constructor(input: DeleteLoggingConfigurationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLoggingConfigurationCommandInput, DeleteLoggingConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeletePermissionPolicyRequest, DeletePermissionPolicyResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeletePermissionPolicyCommandInput extends DeletePermissionPolicyRequest {
+}
+export interface DeletePermissionPolicyCommandOutput extends DeletePermissionPolicyResponse, __MetadataBearer {
+}
+
+export declare class DeletePermissionPolicyCommand extends $Command<DeletePermissionPolicyCommandInput, DeletePermissionPolicyCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeletePermissionPolicyCommandInput;
+    constructor(input: DeletePermissionPolicyCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePermissionPolicyCommandInput, DeletePermissionPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteRateBasedRuleRequest, DeleteRateBasedRuleResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteRateBasedRuleCommandInput extends DeleteRateBasedRuleRequest {
+}
+export interface DeleteRateBasedRuleCommandOutput extends DeleteRateBasedRuleResponse, __MetadataBearer {
+}
+
+export declare class DeleteRateBasedRuleCommand extends $Command<DeleteRateBasedRuleCommandInput, DeleteRateBasedRuleCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteRateBasedRuleCommandInput;
+    constructor(input: DeleteRateBasedRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRateBasedRuleCommandInput, DeleteRateBasedRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteRegexMatchSetRequest, DeleteRegexMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteRegexMatchSetCommandInput extends DeleteRegexMatchSetRequest {
+}
+export interface DeleteRegexMatchSetCommandOutput extends DeleteRegexMatchSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteRegexMatchSetCommand extends $Command<DeleteRegexMatchSetCommandInput, DeleteRegexMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteRegexMatchSetCommandInput;
+    constructor(input: DeleteRegexMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRegexMatchSetCommandInput, DeleteRegexMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteRegexPatternSetRequest, DeleteRegexPatternSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteRegexPatternSetCommandInput extends DeleteRegexPatternSetRequest {
+}
+export interface DeleteRegexPatternSetCommandOutput extends DeleteRegexPatternSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteRegexPatternSetCommand extends $Command<DeleteRegexPatternSetCommandInput, DeleteRegexPatternSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteRegexPatternSetCommandInput;
+    constructor(input: DeleteRegexPatternSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRegexPatternSetCommandInput, DeleteRegexPatternSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteRuleRequest, DeleteRuleResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteRuleCommandInput extends DeleteRuleRequest {
+}
+export interface DeleteRuleCommandOutput extends DeleteRuleResponse, __MetadataBearer {
+}
+
+export declare class DeleteRuleCommand extends $Command<DeleteRuleCommandInput, DeleteRuleCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteRuleCommandInput;
+    constructor(input: DeleteRuleCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRuleCommandInput, DeleteRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteRuleGroupRequest, DeleteRuleGroupResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteRuleGroupCommandInput extends DeleteRuleGroupRequest {
+}
+export interface DeleteRuleGroupCommandOutput extends DeleteRuleGroupResponse, __MetadataBearer {
+}
+
+export declare class DeleteRuleGroupCommand extends $Command<DeleteRuleGroupCommandInput, DeleteRuleGroupCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteRuleGroupCommandInput;
+    constructor(input: DeleteRuleGroupCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRuleGroupCommandInput, DeleteRuleGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteSizeConstraintSetRequest, DeleteSizeConstraintSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteSizeConstraintSetCommandInput extends DeleteSizeConstraintSetRequest {
+}
+export interface DeleteSizeConstraintSetCommandOutput extends DeleteSizeConstraintSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteSizeConstraintSetCommand extends $Command<DeleteSizeConstraintSetCommandInput, DeleteSizeConstraintSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteSizeConstraintSetCommandInput;
+    constructor(input: DeleteSizeConstraintSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSizeConstraintSetCommandInput, DeleteSizeConstraintSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteSqlInjectionMatchSetRequest, DeleteSqlInjectionMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteSqlInjectionMatchSetCommandInput extends DeleteSqlInjectionMatchSetRequest {
+}
+export interface DeleteSqlInjectionMatchSetCommandOutput extends DeleteSqlInjectionMatchSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteSqlInjectionMatchSetCommand extends $Command<DeleteSqlInjectionMatchSetCommandInput, DeleteSqlInjectionMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteSqlInjectionMatchSetCommandInput;
+    constructor(input: DeleteSqlInjectionMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSqlInjectionMatchSetCommandInput, DeleteSqlInjectionMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteWebACLRequest, DeleteWebACLResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteWebACLCommandInput extends DeleteWebACLRequest {
+}
+export interface DeleteWebACLCommandOutput extends DeleteWebACLResponse, __MetadataBearer {
+}
+
+export declare class DeleteWebACLCommand extends $Command<DeleteWebACLCommandInput, DeleteWebACLCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteWebACLCommandInput;
+    constructor(input: DeleteWebACLCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteWebACLCommandInput, DeleteWebACLCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { DeleteXssMatchSetRequest, DeleteXssMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface DeleteXssMatchSetCommandInput extends DeleteXssMatchSetRequest {
+}
+export interface DeleteXssMatchSetCommandOutput extends DeleteXssMatchSetResponse, __MetadataBearer {
+}
+
+export declare class DeleteXssMatchSetCommand extends $Command<DeleteXssMatchSetCommandInput, DeleteXssMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: DeleteXssMatchSetCommandInput;
+    constructor(input: DeleteXssMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteXssMatchSetCommandInput, DeleteXssMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetByteMatchSetRequest, GetByteMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface GetByteMatchSetCommandInput extends GetByteMatchSetRequest {
+}
+export interface GetByteMatchSetCommandOutput extends GetByteMatchSetResponse, __MetadataBearer {
+}
+
+export declare class GetByteMatchSetCommand extends $Command<GetByteMatchSetCommandInput, GetByteMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: GetByteMatchSetCommandInput;
+    constructor(input: GetByteMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetByteMatchSetCommandInput, GetByteMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetChangeTokenRequest, GetChangeTokenResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface GetChangeTokenCommandInput extends GetChangeTokenRequest {
+}
+export interface GetChangeTokenCommandOutput extends GetChangeTokenResponse, __MetadataBearer {
+}
+
+export declare class GetChangeTokenCommand extends $Command<GetChangeTokenCommandInput, GetChangeTokenCommandOutput, WAFClientResolvedConfig> {
+    readonly input: GetChangeTokenCommandInput;
+    constructor(input: GetChangeTokenCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetChangeTokenCommandInput, GetChangeTokenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetChangeTokenStatusRequest, GetChangeTokenStatusResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface GetChangeTokenStatusCommandInput extends GetChangeTokenStatusRequest {
+}
+export interface GetChangeTokenStatusCommandOutput extends GetChangeTokenStatusResponse, __MetadataBearer {
+}
+
+export declare class GetChangeTokenStatusCommand extends $Command<GetChangeTokenStatusCommandInput, GetChangeTokenStatusCommandOutput, WAFClientResolvedConfig> {
+    readonly input: GetChangeTokenStatusCommandInput;
+    constructor(input: GetChangeTokenStatusCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetChangeTokenStatusCommandInput, GetChangeTokenStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetGeoMatchSetRequest, GetGeoMatchSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface GetGeoMatchSetCommandInput extends GetGeoMatchSetRequest {
+}
+export interface GetGeoMatchSetCommandOutput extends GetGeoMatchSetResponse, __MetadataBearer {
+}
+
+export declare class GetGeoMatchSetCommand extends $Command<GetGeoMatchSetCommandInput, GetGeoMatchSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: GetGeoMatchSetCommandInput;
+    constructor(input: GetGeoMatchSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGeoMatchSetCommandInput, GetGeoMatchSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetIPSetRequest, GetIPSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface GetIPSetCommandInput extends GetIPSetRequest {
+}
+export interface GetIPSetCommandOutput extends GetIPSetResponse, __MetadataBearer {
+}
+
+export declare class GetIPSetCommand extends $Command<GetIPSetCommandInput, GetIPSetCommandOutput, WAFClientResolvedConfig> {
+    readonly input: GetIPSetCommandInput;
+    constructor(input: GetIPSetCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIPSetCommandInput, GetIPSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetLoggingConfigurationRequest, GetLoggingConfigurationResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface GetLoggingConfigurationCommandInput extends GetLoggingConfigurationRequest {
+}
+export interface GetLoggingConfigurationCommandOutput extends GetLoggingConfigurationResponse, __MetadataBearer {
+}
+
+export declare class GetLoggingConfigurationCommand extends $Command<GetLoggingConfigurationCommandInput, GetLoggingConfigurationCommandOutput, WAFClientResolvedConfig> {
+    readonly input: GetLoggingConfigurationCommandInput;
+    constructor(input: GetLoggingConfigurationCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLoggingConfigurationCommandInput, GetLoggingConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,17 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetPermissionPolicyRequest, GetPermissionPolicyResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, WAFClientResolvedConfig } from "../WAFClient";
+export interface GetPermissionPolicyCommandInput extends GetPermissionPolicyRequest {
+}
+export interface GetPermissionPolicyCommandOutput extends GetPermissionPolicyResponse, __MetadataBearer {
+}
+
+export declare class GetPermissionPolicyCommand extends $Command<GetPermissionPolicyCommandInput, GetPermissionPolicyCommandOutput, WAFClientResolvedConfig> {
+    readonly input: GetPermissionPolicyCommandInput;
+    constructor(input: GetPermissionPolicyCommandInput);
+    
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: WAFClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetPermissionPolicyCommandInput, GetPermissionPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}