@aws-sdk/client-waf 3.183.0 → 3.185.0

package/dist-es/commands/GetChangeTokenStatusCommand.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 { GetChangeTokenStatusRequestFilterSensitiveLog, GetChangeTokenStatusResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetChangeTokenStatusCommand, serializeAws_json1_1GetChangeTokenStatusCommand, } from "../protocols/Aws_json1_1";
-export class GetChangeTokenStatusCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetChangeTokenStatusCommand = (function (_super) {
+    __extends(GetChangeTokenStatusCommand, _super);
+    function GetChangeTokenStatusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetChangeTokenStatusCommand.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 = "GetChangeTokenStatusCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "GetChangeTokenStatusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetChangeTokenStatusRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetChangeTokenStatusResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetChangeTokenStatusCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetChangeTokenStatusCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetChangeTokenStatusCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetChangeTokenStatusCommand(output, context);
-    }
-}
+    };
+    return GetChangeTokenStatusCommand;
+}($Command));
+export { GetChangeTokenStatusCommand };

package/dist-es/commands/GetGeoMatchSetCommand.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 { GetGeoMatchSetRequestFilterSensitiveLog, GetGeoMatchSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetGeoMatchSetCommand, serializeAws_json1_1GetGeoMatchSetCommand, } from "../protocols/Aws_json1_1";
-export class GetGeoMatchSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetGeoMatchSetCommand = (function (_super) {
+    __extends(GetGeoMatchSetCommand, _super);
+    function GetGeoMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetGeoMatchSetCommand.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 = "GetGeoMatchSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "WAFClient";
+        var commandName = "GetGeoMatchSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetGeoMatchSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetGeoMatchSetResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetGeoMatchSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetGeoMatchSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetGeoMatchSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetGeoMatchSetCommand(output, context);
-    }
-}
+    };
+    return GetGeoMatchSetCommand;
+}($Command));
+export { GetGeoMatchSetCommand };

package/dist-es/commands/GetIPSetCommand.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 { GetIPSetRequestFilterSensitiveLog, GetIPSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetIPSetCommand, serializeAws_json1_1GetIPSetCommand } from "../protocols/Aws_json1_1";
-export class GetIPSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetIPSetCommand = (function (_super) {
+    __extends(GetIPSetCommand, _super);
+    function GetIPSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetIPSetCommand.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 = "GetIPSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetIPSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetIPSetResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetIPSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetIPSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetIPSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetIPSetCommand(output, context);
-    }
-}
+    };
+    return GetIPSetCommand;
+}($Command));
+export { GetIPSetCommand };

package/dist-es/commands/GetLoggingConfigurationCommand.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 { GetLoggingConfigurationRequestFilterSensitiveLog, GetLoggingConfigurationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetLoggingConfigurationCommand, serializeAws_json1_1GetLoggingConfigurationCommand, } from "../protocols/Aws_json1_1";
-export class GetLoggingConfigurationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetLoggingConfigurationCommand = (function (_super) {
+    __extends(GetLoggingConfigurationCommand, _super);
+    function GetLoggingConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetLoggingConfigurationCommand.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 = "GetLoggingConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetLoggingConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetLoggingConfigurationResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetLoggingConfigurationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetLoggingConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetLoggingConfigurationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetLoggingConfigurationCommand(output, context);
-    }
-}
+    };
+    return GetLoggingConfigurationCommand;
+}($Command));
+export { GetLoggingConfigurationCommand };

package/dist-es/commands/GetPermissionPolicyCommand.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 { GetPermissionPolicyRequestFilterSensitiveLog, GetPermissionPolicyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetPermissionPolicyCommand, serializeAws_json1_1GetPermissionPolicyCommand, } from "../protocols/Aws_json1_1";
-export class GetPermissionPolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetPermissionPolicyCommand = (function (_super) {
+    __extends(GetPermissionPolicyCommand, _super);
+    function GetPermissionPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetPermissionPolicyCommand.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 = "GetPermissionPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetPermissionPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetPermissionPolicyResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetPermissionPolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetPermissionPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetPermissionPolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetPermissionPolicyCommand(output, context);
-    }
-}
+    };
+    return GetPermissionPolicyCommand;
+}($Command));
+export { GetPermissionPolicyCommand };

package/dist-es/commands/GetRateBasedRuleCommand.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 { GetRateBasedRuleRequestFilterSensitiveLog, GetRateBasedRuleResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetRateBasedRuleCommand, serializeAws_json1_1GetRateBasedRuleCommand, } from "../protocols/Aws_json1_1";
-export class GetRateBasedRuleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRateBasedRuleCommand = (function (_super) {
+    __extends(GetRateBasedRuleCommand, _super);
+    function GetRateBasedRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRateBasedRuleCommand.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 = "GetRateBasedRuleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRateBasedRuleRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRateBasedRuleResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetRateBasedRuleCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRateBasedRuleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRateBasedRuleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRateBasedRuleCommand(output, context);
-    }
-}
+    };
+    return GetRateBasedRuleCommand;
+}($Command));
+export { GetRateBasedRuleCommand };

package/dist-es/commands/GetRateBasedRuleManagedKeysCommand.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 { GetRateBasedRuleManagedKeysRequestFilterSensitiveLog, GetRateBasedRuleManagedKeysResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetRateBasedRuleManagedKeysCommand, serializeAws_json1_1GetRateBasedRuleManagedKeysCommand, } from "../protocols/Aws_json1_1";
-export class GetRateBasedRuleManagedKeysCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRateBasedRuleManagedKeysCommand = (function (_super) {
+    __extends(GetRateBasedRuleManagedKeysCommand, _super);
+    function GetRateBasedRuleManagedKeysCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRateBasedRuleManagedKeysCommand.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 = "GetRateBasedRuleManagedKeysCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRateBasedRuleManagedKeysRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRateBasedRuleManagedKeysResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetRateBasedRuleManagedKeysCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRateBasedRuleManagedKeysCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRateBasedRuleManagedKeysCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRateBasedRuleManagedKeysCommand(output, context);
-    }
-}
+    };
+    return GetRateBasedRuleManagedKeysCommand;
+}($Command));
+export { GetRateBasedRuleManagedKeysCommand };

package/dist-es/commands/GetRegexMatchSetCommand.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 { GetRegexMatchSetRequestFilterSensitiveLog, GetRegexMatchSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetRegexMatchSetCommand, serializeAws_json1_1GetRegexMatchSetCommand, } from "../protocols/Aws_json1_1";
-export class GetRegexMatchSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRegexMatchSetCommand = (function (_super) {
+    __extends(GetRegexMatchSetCommand, _super);
+    function GetRegexMatchSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRegexMatchSetCommand.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 = "GetRegexMatchSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRegexMatchSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRegexMatchSetResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetRegexMatchSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRegexMatchSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRegexMatchSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRegexMatchSetCommand(output, context);
-    }
-}
+    };
+    return GetRegexMatchSetCommand;
+}($Command));
+export { GetRegexMatchSetCommand };

package/dist-es/commands/GetRegexPatternSetCommand.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 { GetRegexPatternSetRequestFilterSensitiveLog, GetRegexPatternSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetRegexPatternSetCommand, serializeAws_json1_1GetRegexPatternSetCommand, } from "../protocols/Aws_json1_1";
-export class GetRegexPatternSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRegexPatternSetCommand = (function (_super) {
+    __extends(GetRegexPatternSetCommand, _super);
+    function GetRegexPatternSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRegexPatternSetCommand.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 = "GetRegexPatternSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRegexPatternSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRegexPatternSetResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetRegexPatternSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRegexPatternSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRegexPatternSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRegexPatternSetCommand(output, context);
-    }
-}
+    };
+    return GetRegexPatternSetCommand;
+}($Command));
+export { GetRegexPatternSetCommand };

package/dist-es/commands/GetRuleCommand.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 { GetRuleRequestFilterSensitiveLog, GetRuleResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1GetRuleCommand, serializeAws_json1_1GetRuleCommand } from "../protocols/Aws_json1_1";
-export class GetRuleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRuleCommand = (function (_super) {
+    __extends(GetRuleCommand, _super);
+    function GetRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRuleCommand.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 = "GetRuleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRuleRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRuleResponseFilterSensitiveLog,
         };
-        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);
+    };
+    GetRuleCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRuleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRuleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRuleCommand(output, context);
-    }
-}
+    };
+    return GetRuleCommand;
+}($Command));
+export { GetRuleCommand };