@aws-sdk/client-waf 3.32.0 → 3.36.0

package/dist-es/WAFClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var WAFClient = (function (_super) {
+    __extends(WAFClient, _super);
+    function WAFClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    WAFClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return WAFClient;
+}(__Client));
+export { WAFClient };

package/dist-es/commands/CreateByteMatchSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateByteMatchSetRequest, CreateByteMatchSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateByteMatchSetCommand, serializeAws_json1_1CreateByteMatchSetCommand, } from "../protocols/Aws_json1_1";
+var CreateByteMatchSetCommand = (function (_super) {
+    __extends(CreateByteMatchSetCommand, _super);
+    function CreateByteMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateByteMatchSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateByteMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateByteMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateByteMatchSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateByteMatchSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateByteMatchSetCommand(input, context);
+    };
+    CreateByteMatchSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateByteMatchSetCommand(output, context);
+    };
+    return CreateByteMatchSetCommand;
+}($Command));
+export { CreateByteMatchSetCommand };

package/dist-es/commands/CreateGeoMatchSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateGeoMatchSetRequest, CreateGeoMatchSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateGeoMatchSetCommand, serializeAws_json1_1CreateGeoMatchSetCommand, } from "../protocols/Aws_json1_1";
+var CreateGeoMatchSetCommand = (function (_super) {
+    __extends(CreateGeoMatchSetCommand, _super);
+    function CreateGeoMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateGeoMatchSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateGeoMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateGeoMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateGeoMatchSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateGeoMatchSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateGeoMatchSetCommand(input, context);
+    };
+    CreateGeoMatchSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateGeoMatchSetCommand(output, context);
+    };
+    return CreateGeoMatchSetCommand;
+}($Command));
+export { CreateGeoMatchSetCommand };

package/dist-es/commands/CreateIPSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateIPSetRequest, CreateIPSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateIPSetCommand, serializeAws_json1_1CreateIPSetCommand, } from "../protocols/Aws_json1_1";
+var CreateIPSetCommand = (function (_super) {
+    __extends(CreateIPSetCommand, _super);
+    function CreateIPSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateIPSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateIPSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateIPSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateIPSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateIPSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateIPSetCommand(input, context);
+    };
+    CreateIPSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateIPSetCommand(output, context);
+    };
+    return CreateIPSetCommand;
+}($Command));
+export { CreateIPSetCommand };

package/dist-es/commands/CreateRateBasedRuleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateRateBasedRuleRequest, CreateRateBasedRuleResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateRateBasedRuleCommand, serializeAws_json1_1CreateRateBasedRuleCommand, } from "../protocols/Aws_json1_1";
+var CreateRateBasedRuleCommand = (function (_super) {
+    __extends(CreateRateBasedRuleCommand, _super);
+    function CreateRateBasedRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateRateBasedRuleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateRateBasedRuleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateRateBasedRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateRateBasedRuleResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRateBasedRuleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateRateBasedRuleCommand(input, context);
+    };
+    CreateRateBasedRuleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateRateBasedRuleCommand(output, context);
+    };
+    return CreateRateBasedRuleCommand;
+}($Command));
+export { CreateRateBasedRuleCommand };

package/dist-es/commands/CreateRegexMatchSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateRegexMatchSetRequest, CreateRegexMatchSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateRegexMatchSetCommand, serializeAws_json1_1CreateRegexMatchSetCommand, } from "../protocols/Aws_json1_1";
+var CreateRegexMatchSetCommand = (function (_super) {
+    __extends(CreateRegexMatchSetCommand, _super);
+    function CreateRegexMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateRegexMatchSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateRegexMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateRegexMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateRegexMatchSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRegexMatchSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateRegexMatchSetCommand(input, context);
+    };
+    CreateRegexMatchSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateRegexMatchSetCommand(output, context);
+    };
+    return CreateRegexMatchSetCommand;
+}($Command));
+export { CreateRegexMatchSetCommand };

package/dist-es/commands/CreateRegexPatternSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateRegexPatternSetRequest, CreateRegexPatternSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateRegexPatternSetCommand, serializeAws_json1_1CreateRegexPatternSetCommand, } from "../protocols/Aws_json1_1";
+var CreateRegexPatternSetCommand = (function (_super) {
+    __extends(CreateRegexPatternSetCommand, _super);
+    function CreateRegexPatternSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateRegexPatternSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateRegexPatternSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateRegexPatternSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateRegexPatternSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRegexPatternSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateRegexPatternSetCommand(input, context);
+    };
+    CreateRegexPatternSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateRegexPatternSetCommand(output, context);
+    };
+    return CreateRegexPatternSetCommand;
+}($Command));
+export { CreateRegexPatternSetCommand };

package/dist-es/commands/CreateRuleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateRuleRequest, CreateRuleResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateRuleCommand, serializeAws_json1_1CreateRuleCommand, } from "../protocols/Aws_json1_1";
+var CreateRuleCommand = (function (_super) {
+    __extends(CreateRuleCommand, _super);
+    function CreateRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateRuleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateRuleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateRuleResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRuleCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateRuleCommand(input, context);
+    };
+    CreateRuleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateRuleCommand(output, context);
+    };
+    return CreateRuleCommand;
+}($Command));
+export { CreateRuleCommand };

package/dist-es/commands/CreateRuleGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateRuleGroupRequest, CreateRuleGroupResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateRuleGroupCommand, serializeAws_json1_1CreateRuleGroupCommand, } from "../protocols/Aws_json1_1";
+var CreateRuleGroupCommand = (function (_super) {
+    __extends(CreateRuleGroupCommand, _super);
+    function CreateRuleGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateRuleGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateRuleGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateRuleGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateRuleGroupResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateRuleGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateRuleGroupCommand(input, context);
+    };
+    CreateRuleGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateRuleGroupCommand(output, context);
+    };
+    return CreateRuleGroupCommand;
+}($Command));
+export { CreateRuleGroupCommand };

package/dist-es/commands/CreateSizeConstraintSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateSizeConstraintSetRequest, CreateSizeConstraintSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateSizeConstraintSetCommand, serializeAws_json1_1CreateSizeConstraintSetCommand, } from "../protocols/Aws_json1_1";
+var CreateSizeConstraintSetCommand = (function (_super) {
+    __extends(CreateSizeConstraintSetCommand, _super);
+    function CreateSizeConstraintSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateSizeConstraintSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateSizeConstraintSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateSizeConstraintSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateSizeConstraintSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSizeConstraintSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateSizeConstraintSetCommand(input, context);
+    };
+    CreateSizeConstraintSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateSizeConstraintSetCommand(output, context);
+    };
+    return CreateSizeConstraintSetCommand;
+}($Command));
+export { CreateSizeConstraintSetCommand };

package/dist-es/commands/CreateSqlInjectionMatchSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateSqlInjectionMatchSetRequest, CreateSqlInjectionMatchSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateSqlInjectionMatchSetCommand, serializeAws_json1_1CreateSqlInjectionMatchSetCommand, } from "../protocols/Aws_json1_1";
+var CreateSqlInjectionMatchSetCommand = (function (_super) {
+    __extends(CreateSqlInjectionMatchSetCommand, _super);
+    function CreateSqlInjectionMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateSqlInjectionMatchSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateSqlInjectionMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateSqlInjectionMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateSqlInjectionMatchSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSqlInjectionMatchSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateSqlInjectionMatchSetCommand(input, context);
+    };
+    CreateSqlInjectionMatchSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateSqlInjectionMatchSetCommand(output, context);
+    };
+    return CreateSqlInjectionMatchSetCommand;
+}($Command));
+export { CreateSqlInjectionMatchSetCommand };

package/dist-es/commands/CreateWebACLCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateWebACLRequest, CreateWebACLResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateWebACLCommand, serializeAws_json1_1CreateWebACLCommand, } from "../protocols/Aws_json1_1";
+var CreateWebACLCommand = (function (_super) {
+    __extends(CreateWebACLCommand, _super);
+    function CreateWebACLCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateWebACLCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateWebACLCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateWebACLRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateWebACLResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateWebACLCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateWebACLCommand(input, context);
+    };
+    CreateWebACLCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateWebACLCommand(output, context);
+    };
+    return CreateWebACLCommand;
+}($Command));
+export { CreateWebACLCommand };

package/dist-es/commands/CreateWebACLMigrationStackCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateWebACLMigrationStackRequest, CreateWebACLMigrationStackResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateWebACLMigrationStackCommand, serializeAws_json1_1CreateWebACLMigrationStackCommand, } from "../protocols/Aws_json1_1";
+var CreateWebACLMigrationStackCommand = (function (_super) {
+    __extends(CreateWebACLMigrationStackCommand, _super);
+    function CreateWebACLMigrationStackCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateWebACLMigrationStackCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateWebACLMigrationStackCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateWebACLMigrationStackRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateWebACLMigrationStackResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateWebACLMigrationStackCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateWebACLMigrationStackCommand(input, context);
+    };
+    CreateWebACLMigrationStackCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateWebACLMigrationStackCommand(output, context);
+    };
+    return CreateWebACLMigrationStackCommand;
+}($Command));
+export { CreateWebACLMigrationStackCommand };

package/dist-es/commands/CreateXssMatchSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateXssMatchSetRequest, CreateXssMatchSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1CreateXssMatchSetCommand, serializeAws_json1_1CreateXssMatchSetCommand, } from "../protocols/Aws_json1_1";
+var CreateXssMatchSetCommand = (function (_super) {
+    __extends(CreateXssMatchSetCommand, _super);
+    function CreateXssMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateXssMatchSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "CreateXssMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateXssMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateXssMatchSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateXssMatchSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1CreateXssMatchSetCommand(input, context);
+    };
+    CreateXssMatchSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1CreateXssMatchSetCommand(output, context);
+    };
+    return CreateXssMatchSetCommand;
+}($Command));
+export { CreateXssMatchSetCommand };

package/dist-es/commands/DeleteByteMatchSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteByteMatchSetRequest, DeleteByteMatchSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteByteMatchSetCommand, serializeAws_json1_1DeleteByteMatchSetCommand, } from "../protocols/Aws_json1_1";
+var DeleteByteMatchSetCommand = (function (_super) {
+    __extends(DeleteByteMatchSetCommand, _super);
+    function DeleteByteMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteByteMatchSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "DeleteByteMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteByteMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteByteMatchSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteByteMatchSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteByteMatchSetCommand(input, context);
+    };
+    DeleteByteMatchSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteByteMatchSetCommand(output, context);
+    };
+    return DeleteByteMatchSetCommand;
+}($Command));
+export { DeleteByteMatchSetCommand };

package/dist-es/commands/DeleteGeoMatchSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteGeoMatchSetRequest, DeleteGeoMatchSetResponse } from "../models/models_0";
+import { deserializeAws_json1_1DeleteGeoMatchSetCommand, serializeAws_json1_1DeleteGeoMatchSetCommand, } from "../protocols/Aws_json1_1";
+var DeleteGeoMatchSetCommand = (function (_super) {
+    __extends(DeleteGeoMatchSetCommand, _super);
+    function DeleteGeoMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteGeoMatchSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "DeleteGeoMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteGeoMatchSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteGeoMatchSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteGeoMatchSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DeleteGeoMatchSetCommand(input, context);
+    };
+    DeleteGeoMatchSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DeleteGeoMatchSetCommand(output, context);
+    };
+    return DeleteGeoMatchSetCommand;
+}($Command));
+export { DeleteGeoMatchSetCommand };