@aws-sdk/client-route53resolver 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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