@aws-sdk/client-route53resolver 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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