@aws-sdk/client-waf 3.183.0 → 3.186.0

package/dist-es/commands/ListLoggingConfigurationsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListLoggingConfigurationsRequestFilterSensitiveLog, ListLoggingConfigurationsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListLoggingConfigurationsCommand, serializeAws_json1_1ListLoggingConfigurationsCommand, } from "../protocols/Aws_json1_1";
-export class ListLoggingConfigurationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListLoggingConfigurationsCommand = (function (_super) {
+    __extends(ListLoggingConfigurationsCommand, _super);
+    function ListLoggingConfigurationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListLoggingConfigurationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListLoggingConfigurationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListLoggingConfigurationsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListLoggingConfigurationsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListLoggingConfigurationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListLoggingConfigurationsCommand(output, context);
-    }
-}
+    };
+    return ListLoggingConfigurationsCommand;
+}($Command));
+export { ListLoggingConfigurationsCommand };

package/dist-es/commands/ListRateBasedRulesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListRateBasedRulesRequestFilterSensitiveLog, ListRateBasedRulesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListRateBasedRulesCommand, serializeAws_json1_1ListRateBasedRulesCommand, } from "../protocols/Aws_json1_1";
-export class ListRateBasedRulesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListRateBasedRulesCommand = (function (_super) {
+    __extends(ListRateBasedRulesCommand, _super);
+    function ListRateBasedRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListRateBasedRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListRateBasedRulesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListRateBasedRulesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListRateBasedRulesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListRateBasedRulesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListRateBasedRulesCommand(output, context);
-    }
-}
+    };
+    return ListRateBasedRulesCommand;
+}($Command));
+export { ListRateBasedRulesCommand };

package/dist-es/commands/ListRegexMatchSetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListRegexMatchSetsRequestFilterSensitiveLog, ListRegexMatchSetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListRegexMatchSetsCommand, serializeAws_json1_1ListRegexMatchSetsCommand, } from "../protocols/Aws_json1_1";
-export class ListRegexMatchSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListRegexMatchSetsCommand = (function (_super) {
+    __extends(ListRegexMatchSetsCommand, _super);
+    function ListRegexMatchSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListRegexMatchSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListRegexMatchSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListRegexMatchSetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListRegexMatchSetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListRegexMatchSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListRegexMatchSetsCommand(output, context);
-    }
-}
+    };
+    return ListRegexMatchSetsCommand;
+}($Command));
+export { ListRegexMatchSetsCommand };

package/dist-es/commands/ListRegexPatternSetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListRegexPatternSetsRequestFilterSensitiveLog, ListRegexPatternSetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListRegexPatternSetsCommand, serializeAws_json1_1ListRegexPatternSetsCommand, } from "../protocols/Aws_json1_1";
-export class ListRegexPatternSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListRegexPatternSetsCommand = (function (_super) {
+    __extends(ListRegexPatternSetsCommand, _super);
+    function ListRegexPatternSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListRegexPatternSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListRegexPatternSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListRegexPatternSetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListRegexPatternSetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListRegexPatternSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListRegexPatternSetsCommand(output, context);
-    }
-}
+    };
+    return ListRegexPatternSetsCommand;
+}($Command));
+export { ListRegexPatternSetsCommand };

package/dist-es/commands/ListRuleGroupsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListRuleGroupsRequestFilterSensitiveLog, ListRuleGroupsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListRuleGroupsCommand, serializeAws_json1_1ListRuleGroupsCommand, } from "../protocols/Aws_json1_1";
-export class ListRuleGroupsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListRuleGroupsCommand = (function (_super) {
+    __extends(ListRuleGroupsCommand, _super);
+    function ListRuleGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListRuleGroupsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListRuleGroupsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListRuleGroupsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListRuleGroupsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListRuleGroupsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListRuleGroupsCommand(output, context);
-    }
-}
+    };
+    return ListRuleGroupsCommand;
+}($Command));
+export { ListRuleGroupsCommand };

package/dist-es/commands/ListRulesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListRulesRequestFilterSensitiveLog, ListRulesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListRulesCommand, serializeAws_json1_1ListRulesCommand } from "../protocols/Aws_json1_1";
-export class ListRulesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListRulesCommand = (function (_super) {
+    __extends(ListRulesCommand, _super);
+    function ListRulesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListRulesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListRulesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListRulesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListRulesResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListRulesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListRulesCommand(output, context);
-    }
-}
+    };
+    return ListRulesCommand;
+}($Command));
+export { ListRulesCommand };

package/dist-es/commands/ListSizeConstraintSetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListSizeConstraintSetsRequestFilterSensitiveLog, ListSizeConstraintSetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListSizeConstraintSetsCommand, serializeAws_json1_1ListSizeConstraintSetsCommand, } from "../protocols/Aws_json1_1";
-export class ListSizeConstraintSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListSizeConstraintSetsCommand = (function (_super) {
+    __extends(ListSizeConstraintSetsCommand, _super);
+    function ListSizeConstraintSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListSizeConstraintSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListSizeConstraintSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListSizeConstraintSetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListSizeConstraintSetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListSizeConstraintSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListSizeConstraintSetsCommand(output, context);
-    }
-}
+    };
+    return ListSizeConstraintSetsCommand;
+}($Command));
+export { ListSizeConstraintSetsCommand };

package/dist-es/commands/ListSqlInjectionMatchSetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListSqlInjectionMatchSetsRequestFilterSensitiveLog, ListSqlInjectionMatchSetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListSqlInjectionMatchSetsCommand, serializeAws_json1_1ListSqlInjectionMatchSetsCommand, } from "../protocols/Aws_json1_1";
-export class ListSqlInjectionMatchSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListSqlInjectionMatchSetsCommand = (function (_super) {
+    __extends(ListSqlInjectionMatchSetsCommand, _super);
+    function ListSqlInjectionMatchSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListSqlInjectionMatchSetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListSqlInjectionMatchSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListSqlInjectionMatchSetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListSqlInjectionMatchSetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListSqlInjectionMatchSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListSqlInjectionMatchSetsCommand(output, context);
-    }
-}
+    };
+    return ListSqlInjectionMatchSetsCommand;
+}($Command));
+export { ListSqlInjectionMatchSetsCommand };

package/dist-es/commands/ListSubscribedRuleGroupsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListSubscribedRuleGroupsRequestFilterSensitiveLog, ListSubscribedRuleGroupsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListSubscribedRuleGroupsCommand, serializeAws_json1_1ListSubscribedRuleGroupsCommand, } from "../protocols/Aws_json1_1";
-export class ListSubscribedRuleGroupsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListSubscribedRuleGroupsCommand = (function (_super) {
+    __extends(ListSubscribedRuleGroupsCommand, _super);
+    function ListSubscribedRuleGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListSubscribedRuleGroupsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListSubscribedRuleGroupsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListSubscribedRuleGroupsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListSubscribedRuleGroupsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListSubscribedRuleGroupsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListSubscribedRuleGroupsCommand(output, context);
-    }
-}
+    };
+    return ListSubscribedRuleGroupsCommand;
+}($Command));
+export { ListSubscribedRuleGroupsCommand };

package/dist-es/commands/ListTagsForResourceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ListTagsForResourceRequestFilterSensitiveLog, ListTagsForResourceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListTagsForResourceCommand, serializeAws_json1_1ListTagsForResourceCommand, } from "../protocols/Aws_json1_1";
-export class ListTagsForResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTagsForResourceCommand = (function (_super) {
+    __extends(ListTagsForResourceCommand, _super);
+    function ListTagsForResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTagsForResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "WAFClient";
-        const commandName = "ListTagsForResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListTagsForResourceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListTagsForResourceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    ListTagsForResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListTagsForResourceCommand(output, context);
-    }
-}
+    };
+    return ListTagsForResourceCommand;
+}($Command));
+export { ListTagsForResourceCommand };