@aws-sdk/client-waf 3.32.0 → 3.36.0

package/dist-es/commands/ListGeoMatchSetsCommand.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 { ListGeoMatchSetsRequest, ListGeoMatchSetsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListGeoMatchSetsCommand, serializeAws_json1_1ListGeoMatchSetsCommand, } from "../protocols/Aws_json1_1";
+var ListGeoMatchSetsCommand = (function (_super) {
+    __extends(ListGeoMatchSetsCommand, _super);
+    function ListGeoMatchSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListGeoMatchSetsCommand.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 = "ListGeoMatchSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListGeoMatchSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListGeoMatchSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListGeoMatchSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListGeoMatchSetsCommand(input, context);
+    };
+    ListGeoMatchSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListGeoMatchSetsCommand(output, context);
+    };
+    return ListGeoMatchSetsCommand;
+}($Command));
+export { ListGeoMatchSetsCommand };

package/dist-es/commands/ListIPSetsCommand.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 { ListIPSetsRequest, ListIPSetsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListIPSetsCommand, serializeAws_json1_1ListIPSetsCommand, } from "../protocols/Aws_json1_1";
+var ListIPSetsCommand = (function (_super) {
+    __extends(ListIPSetsCommand, _super);
+    function ListIPSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListIPSetsCommand.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 = "ListIPSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListIPSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListIPSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListIPSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListIPSetsCommand(input, context);
+    };
+    ListIPSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListIPSetsCommand(output, context);
+    };
+    return ListIPSetsCommand;
+}($Command));
+export { ListIPSetsCommand };

package/dist-es/commands/ListLoggingConfigurationsCommand.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 { ListLoggingConfigurationsRequest, ListLoggingConfigurationsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListLoggingConfigurationsCommand, serializeAws_json1_1ListLoggingConfigurationsCommand, } from "../protocols/Aws_json1_1";
+var ListLoggingConfigurationsCommand = (function (_super) {
+    __extends(ListLoggingConfigurationsCommand, _super);
+    function ListLoggingConfigurationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListLoggingConfigurationsCommand.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 = "ListLoggingConfigurationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListLoggingConfigurationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListLoggingConfigurationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListLoggingConfigurationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListLoggingConfigurationsCommand(input, context);
+    };
+    ListLoggingConfigurationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListLoggingConfigurationsCommand(output, context);
+    };
+    return ListLoggingConfigurationsCommand;
+}($Command));
+export { ListLoggingConfigurationsCommand };

package/dist-es/commands/ListRateBasedRulesCommand.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 { ListRateBasedRulesRequest, ListRateBasedRulesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListRateBasedRulesCommand, serializeAws_json1_1ListRateBasedRulesCommand, } from "../protocols/Aws_json1_1";
+var ListRateBasedRulesCommand = (function (_super) {
+    __extends(ListRateBasedRulesCommand, _super);
+    function ListRateBasedRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRateBasedRulesCommand.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 = "ListRateBasedRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRateBasedRulesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRateBasedRulesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRateBasedRulesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListRateBasedRulesCommand(input, context);
+    };
+    ListRateBasedRulesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListRateBasedRulesCommand(output, context);
+    };
+    return ListRateBasedRulesCommand;
+}($Command));
+export { ListRateBasedRulesCommand };

package/dist-es/commands/ListRegexMatchSetsCommand.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 { ListRegexMatchSetsRequest, ListRegexMatchSetsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListRegexMatchSetsCommand, serializeAws_json1_1ListRegexMatchSetsCommand, } from "../protocols/Aws_json1_1";
+var ListRegexMatchSetsCommand = (function (_super) {
+    __extends(ListRegexMatchSetsCommand, _super);
+    function ListRegexMatchSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRegexMatchSetsCommand.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 = "ListRegexMatchSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRegexMatchSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRegexMatchSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRegexMatchSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListRegexMatchSetsCommand(input, context);
+    };
+    ListRegexMatchSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListRegexMatchSetsCommand(output, context);
+    };
+    return ListRegexMatchSetsCommand;
+}($Command));
+export { ListRegexMatchSetsCommand };

package/dist-es/commands/ListRegexPatternSetsCommand.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 { ListRegexPatternSetsRequest, ListRegexPatternSetsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListRegexPatternSetsCommand, serializeAws_json1_1ListRegexPatternSetsCommand, } from "../protocols/Aws_json1_1";
+var ListRegexPatternSetsCommand = (function (_super) {
+    __extends(ListRegexPatternSetsCommand, _super);
+    function ListRegexPatternSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRegexPatternSetsCommand.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 = "ListRegexPatternSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRegexPatternSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRegexPatternSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRegexPatternSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListRegexPatternSetsCommand(input, context);
+    };
+    ListRegexPatternSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListRegexPatternSetsCommand(output, context);
+    };
+    return ListRegexPatternSetsCommand;
+}($Command));
+export { ListRegexPatternSetsCommand };

package/dist-es/commands/ListRuleGroupsCommand.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 { ListRuleGroupsRequest, ListRuleGroupsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListRuleGroupsCommand, serializeAws_json1_1ListRuleGroupsCommand, } from "../protocols/Aws_json1_1";
+var ListRuleGroupsCommand = (function (_super) {
+    __extends(ListRuleGroupsCommand, _super);
+    function ListRuleGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRuleGroupsCommand.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 = "ListRuleGroupsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRuleGroupsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRuleGroupsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRuleGroupsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListRuleGroupsCommand(input, context);
+    };
+    ListRuleGroupsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListRuleGroupsCommand(output, context);
+    };
+    return ListRuleGroupsCommand;
+}($Command));
+export { ListRuleGroupsCommand };

package/dist-es/commands/ListRulesCommand.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 { ListRulesRequest, ListRulesResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListRulesCommand, serializeAws_json1_1ListRulesCommand } from "../protocols/Aws_json1_1";
+var ListRulesCommand = (function (_super) {
+    __extends(ListRulesCommand, _super);
+    function ListRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListRulesCommand.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 = "ListRulesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListRulesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListRulesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListRulesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListRulesCommand(input, context);
+    };
+    ListRulesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListRulesCommand(output, context);
+    };
+    return ListRulesCommand;
+}($Command));
+export { ListRulesCommand };

package/dist-es/commands/ListSizeConstraintSetsCommand.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 { ListSizeConstraintSetsRequest, ListSizeConstraintSetsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListSizeConstraintSetsCommand, serializeAws_json1_1ListSizeConstraintSetsCommand, } from "../protocols/Aws_json1_1";
+var ListSizeConstraintSetsCommand = (function (_super) {
+    __extends(ListSizeConstraintSetsCommand, _super);
+    function ListSizeConstraintSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListSizeConstraintSetsCommand.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 = "ListSizeConstraintSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListSizeConstraintSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListSizeConstraintSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListSizeConstraintSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListSizeConstraintSetsCommand(input, context);
+    };
+    ListSizeConstraintSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListSizeConstraintSetsCommand(output, context);
+    };
+    return ListSizeConstraintSetsCommand;
+}($Command));
+export { ListSizeConstraintSetsCommand };

package/dist-es/commands/ListSqlInjectionMatchSetsCommand.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 { ListSqlInjectionMatchSetsRequest, ListSqlInjectionMatchSetsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListSqlInjectionMatchSetsCommand, serializeAws_json1_1ListSqlInjectionMatchSetsCommand, } from "../protocols/Aws_json1_1";
+var ListSqlInjectionMatchSetsCommand = (function (_super) {
+    __extends(ListSqlInjectionMatchSetsCommand, _super);
+    function ListSqlInjectionMatchSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListSqlInjectionMatchSetsCommand.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 = "ListSqlInjectionMatchSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListSqlInjectionMatchSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListSqlInjectionMatchSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListSqlInjectionMatchSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListSqlInjectionMatchSetsCommand(input, context);
+    };
+    ListSqlInjectionMatchSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListSqlInjectionMatchSetsCommand(output, context);
+    };
+    return ListSqlInjectionMatchSetsCommand;
+}($Command));
+export { ListSqlInjectionMatchSetsCommand };

package/dist-es/commands/ListSubscribedRuleGroupsCommand.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 { ListSubscribedRuleGroupsRequest, ListSubscribedRuleGroupsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListSubscribedRuleGroupsCommand, serializeAws_json1_1ListSubscribedRuleGroupsCommand, } from "../protocols/Aws_json1_1";
+var ListSubscribedRuleGroupsCommand = (function (_super) {
+    __extends(ListSubscribedRuleGroupsCommand, _super);
+    function ListSubscribedRuleGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListSubscribedRuleGroupsCommand.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 = "ListSubscribedRuleGroupsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListSubscribedRuleGroupsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListSubscribedRuleGroupsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListSubscribedRuleGroupsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListSubscribedRuleGroupsCommand(input, context);
+    };
+    ListSubscribedRuleGroupsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListSubscribedRuleGroupsCommand(output, context);
+    };
+    return ListSubscribedRuleGroupsCommand;
+}($Command));
+export { ListSubscribedRuleGroupsCommand };

package/dist-es/commands/ListTagsForResourceCommand.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 { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListTagsForResourceCommand, serializeAws_json1_1ListTagsForResourceCommand, } from "../protocols/Aws_json1_1";
+var ListTagsForResourceCommand = (function (_super) {
+    __extends(ListTagsForResourceCommand, _super);
+    function ListTagsForResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListTagsForResourceCommand.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 = "ListTagsForResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListTagsForResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListTagsForResourceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListTagsForResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListTagsForResourceCommand(input, context);
+    };
+    ListTagsForResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListTagsForResourceCommand(output, context);
+    };
+    return ListTagsForResourceCommand;
+}($Command));
+export { ListTagsForResourceCommand };

package/dist-es/commands/ListWebACLsCommand.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 { ListWebACLsRequest, ListWebACLsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListWebACLsCommand, serializeAws_json1_1ListWebACLsCommand, } from "../protocols/Aws_json1_1";
+var ListWebACLsCommand = (function (_super) {
+    __extends(ListWebACLsCommand, _super);
+    function ListWebACLsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListWebACLsCommand.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 = "ListWebACLsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListWebACLsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListWebACLsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListWebACLsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListWebACLsCommand(input, context);
+    };
+    ListWebACLsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListWebACLsCommand(output, context);
+    };
+    return ListWebACLsCommand;
+}($Command));
+export { ListWebACLsCommand };

package/dist-es/commands/ListXssMatchSetsCommand.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 { ListXssMatchSetsRequest, ListXssMatchSetsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListXssMatchSetsCommand, serializeAws_json1_1ListXssMatchSetsCommand, } from "../protocols/Aws_json1_1";
+var ListXssMatchSetsCommand = (function (_super) {
+    __extends(ListXssMatchSetsCommand, _super);
+    function ListXssMatchSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListXssMatchSetsCommand.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 = "ListXssMatchSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListXssMatchSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListXssMatchSetsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListXssMatchSetsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListXssMatchSetsCommand(input, context);
+    };
+    ListXssMatchSetsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListXssMatchSetsCommand(output, context);
+    };
+    return ListXssMatchSetsCommand;
+}($Command));
+export { ListXssMatchSetsCommand };

package/dist-es/commands/PutLoggingConfigurationCommand.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 { PutLoggingConfigurationRequest, PutLoggingConfigurationResponse } from "../models/models_0";
+import { deserializeAws_json1_1PutLoggingConfigurationCommand, serializeAws_json1_1PutLoggingConfigurationCommand, } from "../protocols/Aws_json1_1";
+var PutLoggingConfigurationCommand = (function (_super) {
+    __extends(PutLoggingConfigurationCommand, _super);
+    function PutLoggingConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutLoggingConfigurationCommand.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 = "PutLoggingConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutLoggingConfigurationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: PutLoggingConfigurationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutLoggingConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1PutLoggingConfigurationCommand(input, context);
+    };
+    PutLoggingConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1PutLoggingConfigurationCommand(output, context);
+    };
+    return PutLoggingConfigurationCommand;
+}($Command));
+export { PutLoggingConfigurationCommand };

package/dist-es/commands/PutPermissionPolicyCommand.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 { PutPermissionPolicyRequest, PutPermissionPolicyResponse } from "../models/models_0";
+import { deserializeAws_json1_1PutPermissionPolicyCommand, serializeAws_json1_1PutPermissionPolicyCommand, } from "../protocols/Aws_json1_1";
+var PutPermissionPolicyCommand = (function (_super) {
+    __extends(PutPermissionPolicyCommand, _super);
+    function PutPermissionPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutPermissionPolicyCommand.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 = "PutPermissionPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutPermissionPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: PutPermissionPolicyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutPermissionPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1PutPermissionPolicyCommand(input, context);
+    };
+    PutPermissionPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1PutPermissionPolicyCommand(output, context);
+    };
+    return PutPermissionPolicyCommand;
+}($Command));
+export { PutPermissionPolicyCommand };