@aws-sdk/client-route53resolver 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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