@aws-sdk/client-migrationhuborchestrator 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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