@aws-sdk/client-drs 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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