@aws-sdk/client-auto-scaling 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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