@aws-sdk/client-waf 3.32.0 → 3.36.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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