@aws-sdk/client-ssm 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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