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

package/dist-es/commands/DetachLoadBalancerTargetGroupsCommand.js

@@ -1,39 +1,32 @@
-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";
-var DetachLoadBalancerTargetGroupsCommand = (function (_super) {
-    __extends(DetachLoadBalancerTargetGroupsCommand, _super);
-    function DetachLoadBalancerTargetGroupsCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DetachLoadBalancerTargetGroupsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DetachLoadBalancerTargetGroupsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "DetachLoadBalancerTargetGroupsCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "DetachLoadBalancerTargetGroupsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DetachLoadBalancerTargetGroupsTypeFilterSensitiveLog,
             outputFilterSensitiveLog: DetachLoadBalancerTargetGroupsResultTypeFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DetachLoadBalancerTargetGroupsCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryDetachLoadBalancerTargetGroupsCommand(input, context);
-    };
-    DetachLoadBalancerTargetGroupsCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryDetachLoadBalancerTargetGroupsCommand(output, context);
-    };
-    return DetachLoadBalancerTargetGroupsCommand;
-}($Command));
-export { DetachLoadBalancerTargetGroupsCommand };
+    }
+}

package/dist-es/commands/DetachLoadBalancersCommand.js

@@ -1,39 +1,32 @@
-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";
-var DetachLoadBalancersCommand = (function (_super) {
-    __extends(DetachLoadBalancersCommand, _super);
-    function DetachLoadBalancersCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DetachLoadBalancersCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DetachLoadBalancersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "DetachLoadBalancersCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "DetachLoadBalancersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DetachLoadBalancersTypeFilterSensitiveLog,
             outputFilterSensitiveLog: DetachLoadBalancersResultTypeFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DetachLoadBalancersCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryDetachLoadBalancersCommand(input, context);
-    };
-    DetachLoadBalancersCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryDetachLoadBalancersCommand(output, context);
-    };
-    return DetachLoadBalancersCommand;
-}($Command));
-export { DetachLoadBalancersCommand };
+    }
+}

package/dist-es/commands/DisableMetricsCollectionCommand.js

@@ -1,39 +1,32 @@
-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";
-var DisableMetricsCollectionCommand = (function (_super) {
-    __extends(DisableMetricsCollectionCommand, _super);
-    function DisableMetricsCollectionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class DisableMetricsCollectionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    DisableMetricsCollectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "DisableMetricsCollectionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "DisableMetricsCollectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: DisableMetricsCollectionQueryFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    DisableMetricsCollectionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryDisableMetricsCollectionCommand(input, context);
-    };
-    DisableMetricsCollectionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryDisableMetricsCollectionCommand(output, context);
-    };
-    return DisableMetricsCollectionCommand;
-}($Command));
-export { DisableMetricsCollectionCommand };
+    }
+}

package/dist-es/commands/EnableMetricsCollectionCommand.js

@@ -1,39 +1,32 @@
-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";
-var EnableMetricsCollectionCommand = (function (_super) {
-    __extends(EnableMetricsCollectionCommand, _super);
-    function EnableMetricsCollectionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class EnableMetricsCollectionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    EnableMetricsCollectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "EnableMetricsCollectionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "EnableMetricsCollectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: EnableMetricsCollectionQueryFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    EnableMetricsCollectionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryEnableMetricsCollectionCommand(input, context);
-    };
-    EnableMetricsCollectionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryEnableMetricsCollectionCommand(output, context);
-    };
-    return EnableMetricsCollectionCommand;
-}($Command));
-export { EnableMetricsCollectionCommand };
+    }
+}

package/dist-es/commands/EnterStandbyCommand.js

@@ -1,39 +1,32 @@
-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";
-var EnterStandbyCommand = (function (_super) {
-    __extends(EnterStandbyCommand, _super);
-    function EnterStandbyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class EnterStandbyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    EnterStandbyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "EnterStandbyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "EnterStandbyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: EnterStandbyQueryFilterSensitiveLog,
             outputFilterSensitiveLog: EnterStandbyAnswerFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    EnterStandbyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryEnterStandbyCommand(input, context);
-    };
-    EnterStandbyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryEnterStandbyCommand(output, context);
-    };
-    return EnterStandbyCommand;
-}($Command));
-export { EnterStandbyCommand };
+    }
+}

package/dist-es/commands/ExecutePolicyCommand.js

@@ -1,39 +1,32 @@
-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";
-var ExecutePolicyCommand = (function (_super) {
-    __extends(ExecutePolicyCommand, _super);
-    function ExecutePolicyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ExecutePolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ExecutePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "ExecutePolicyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "ExecutePolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ExecutePolicyTypeFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ExecutePolicyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryExecutePolicyCommand(input, context);
-    };
-    ExecutePolicyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryExecutePolicyCommand(output, context);
-    };
-    return ExecutePolicyCommand;
-}($Command));
-export { ExecutePolicyCommand };
+    }
+}

package/dist-es/commands/ExitStandbyCommand.js

@@ -1,39 +1,32 @@
-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";
-var ExitStandbyCommand = (function (_super) {
-    __extends(ExitStandbyCommand, _super);
-    function ExitStandbyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ExitStandbyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ExitStandbyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "ExitStandbyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "ExitStandbyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ExitStandbyQueryFilterSensitiveLog,
             outputFilterSensitiveLog: ExitStandbyAnswerFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ExitStandbyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryExitStandbyCommand(input, context);
-    };
-    ExitStandbyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryExitStandbyCommand(output, context);
-    };
-    return ExitStandbyCommand;
-}($Command));
-export { ExitStandbyCommand };
+    }
+}

package/dist-es/commands/GetPredictiveScalingForecastCommand.js

@@ -1,39 +1,32 @@
-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";
-var GetPredictiveScalingForecastCommand = (function (_super) {
-    __extends(GetPredictiveScalingForecastCommand, _super);
-    function GetPredictiveScalingForecastCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetPredictiveScalingForecastCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetPredictiveScalingForecastCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "GetPredictiveScalingForecastCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "GetPredictiveScalingForecastCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetPredictiveScalingForecastTypeFilterSensitiveLog,
             outputFilterSensitiveLog: GetPredictiveScalingForecastAnswerFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetPredictiveScalingForecastCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryGetPredictiveScalingForecastCommand(input, context);
-    };
-    GetPredictiveScalingForecastCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryGetPredictiveScalingForecastCommand(output, context);
-    };
-    return GetPredictiveScalingForecastCommand;
-}($Command));
-export { GetPredictiveScalingForecastCommand };
+    }
+}

package/dist-es/commands/PutLifecycleHookCommand.js

@@ -1,39 +1,32 @@
-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";
-var PutLifecycleHookCommand = (function (_super) {
-    __extends(PutLifecycleHookCommand, _super);
-    function PutLifecycleHookCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class PutLifecycleHookCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    PutLifecycleHookCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "PutLifecycleHookCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "PutLifecycleHookCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: PutLifecycleHookTypeFilterSensitiveLog,
             outputFilterSensitiveLog: PutLifecycleHookAnswerFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    PutLifecycleHookCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryPutLifecycleHookCommand(input, context);
-    };
-    PutLifecycleHookCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryPutLifecycleHookCommand(output, context);
-    };
-    return PutLifecycleHookCommand;
-}($Command));
-export { PutLifecycleHookCommand };
+    }
+}

package/dist-es/commands/PutNotificationConfigurationCommand.js

@@ -1,39 +1,32 @@
-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";
-var PutNotificationConfigurationCommand = (function (_super) {
-    __extends(PutNotificationConfigurationCommand, _super);
-    function PutNotificationConfigurationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class PutNotificationConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    PutNotificationConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "AutoScalingClient";
-        var commandName = "PutNotificationConfigurationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "AutoScalingClient";
+        const commandName = "PutNotificationConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: PutNotificationConfigurationTypeFilterSensitiveLog,
-            outputFilterSensitiveLog: function (output) { return output; },
+            outputFilterSensitiveLog: (output) => output,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    PutNotificationConfigurationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryPutNotificationConfigurationCommand(input, context);
-    };
-    PutNotificationConfigurationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryPutNotificationConfigurationCommand(output, context);
-    };
-    return PutNotificationConfigurationCommand;
-}($Command));
-export { PutNotificationConfigurationCommand };
+    }
+}