@aws-sdk/client-auto-scaling 3.32.0 → 3.36.0

package/dist-es/commands/PutLifecycleHookCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutLifecycleHookAnswer, PutLifecycleHookType } 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;
+    }
+    PutLifecycleHookCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: PutLifecycleHookType.filterSensitiveLog,
+            outputFilterSensitiveLog: PutLifecycleHookAnswer.filterSensitiveLog,
+        };
+        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);
+    };
+    PutLifecycleHookCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryPutLifecycleHookCommand(output, context);
+    };
+    return PutLifecycleHookCommand;
+}($Command));
+export { PutLifecycleHookCommand };

package/dist-es/commands/PutNotificationConfigurationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutNotificationConfigurationType } 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;
+    }
+    PutNotificationConfigurationCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: PutNotificationConfigurationType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    PutNotificationConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryPutNotificationConfigurationCommand(output, context);
+    };
+    return PutNotificationConfigurationCommand;
+}($Command));
+export { PutNotificationConfigurationCommand };

package/dist-es/commands/PutScalingPolicyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PolicyARNType, PutScalingPolicyType } from "../models/models_0";
+import { deserializeAws_queryPutScalingPolicyCommand, serializeAws_queryPutScalingPolicyCommand, } from "../protocols/Aws_query";
+var PutScalingPolicyCommand = (function (_super) {
+    __extends(PutScalingPolicyCommand, _super);
+    function PutScalingPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutScalingPolicyCommand.prototype.resolveMiddleware = function (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 = "PutScalingPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutScalingPolicyType.filterSensitiveLog,
+            outputFilterSensitiveLog: PolicyARNType.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutScalingPolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryPutScalingPolicyCommand(input, context);
+    };
+    PutScalingPolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryPutScalingPolicyCommand(output, context);
+    };
+    return PutScalingPolicyCommand;
+}($Command));
+export { PutScalingPolicyCommand };

package/dist-es/commands/PutScheduledUpdateGroupActionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutScheduledUpdateGroupActionType } from "../models/models_0";
+import { deserializeAws_queryPutScheduledUpdateGroupActionCommand, serializeAws_queryPutScheduledUpdateGroupActionCommand, } from "../protocols/Aws_query";
+var PutScheduledUpdateGroupActionCommand = (function (_super) {
+    __extends(PutScheduledUpdateGroupActionCommand, _super);
+    function PutScheduledUpdateGroupActionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutScheduledUpdateGroupActionCommand.prototype.resolveMiddleware = function (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 = "PutScheduledUpdateGroupActionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutScheduledUpdateGroupActionType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutScheduledUpdateGroupActionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryPutScheduledUpdateGroupActionCommand(input, context);
+    };
+    PutScheduledUpdateGroupActionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryPutScheduledUpdateGroupActionCommand(output, context);
+    };
+    return PutScheduledUpdateGroupActionCommand;
+}($Command));
+export { PutScheduledUpdateGroupActionCommand };

package/dist-es/commands/PutWarmPoolCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { PutWarmPoolAnswer, PutWarmPoolType } from "../models/models_0";
+import { deserializeAws_queryPutWarmPoolCommand, serializeAws_queryPutWarmPoolCommand } from "../protocols/Aws_query";
+var PutWarmPoolCommand = (function (_super) {
+    __extends(PutWarmPoolCommand, _super);
+    function PutWarmPoolCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PutWarmPoolCommand.prototype.resolveMiddleware = function (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 = "PutWarmPoolCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PutWarmPoolType.filterSensitiveLog,
+            outputFilterSensitiveLog: PutWarmPoolAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    PutWarmPoolCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryPutWarmPoolCommand(input, context);
+    };
+    PutWarmPoolCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryPutWarmPoolCommand(output, context);
+    };
+    return PutWarmPoolCommand;
+}($Command));
+export { PutWarmPoolCommand };

package/dist-es/commands/RecordLifecycleActionHeartbeatCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { RecordLifecycleActionHeartbeatAnswer, RecordLifecycleActionHeartbeatType } from "../models/models_0";
+import { deserializeAws_queryRecordLifecycleActionHeartbeatCommand, serializeAws_queryRecordLifecycleActionHeartbeatCommand, } from "../protocols/Aws_query";
+var RecordLifecycleActionHeartbeatCommand = (function (_super) {
+    __extends(RecordLifecycleActionHeartbeatCommand, _super);
+    function RecordLifecycleActionHeartbeatCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RecordLifecycleActionHeartbeatCommand.prototype.resolveMiddleware = function (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 = "RecordLifecycleActionHeartbeatCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RecordLifecycleActionHeartbeatType.filterSensitiveLog,
+            outputFilterSensitiveLog: RecordLifecycleActionHeartbeatAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    RecordLifecycleActionHeartbeatCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryRecordLifecycleActionHeartbeatCommand(input, context);
+    };
+    RecordLifecycleActionHeartbeatCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryRecordLifecycleActionHeartbeatCommand(output, context);
+    };
+    return RecordLifecycleActionHeartbeatCommand;
+}($Command));
+export { RecordLifecycleActionHeartbeatCommand };

package/dist-es/commands/ResumeProcessesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ScalingProcessQuery } from "../models/models_0";
+import { deserializeAws_queryResumeProcessesCommand, serializeAws_queryResumeProcessesCommand, } from "../protocols/Aws_query";
+var ResumeProcessesCommand = (function (_super) {
+    __extends(ResumeProcessesCommand, _super);
+    function ResumeProcessesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ResumeProcessesCommand.prototype.resolveMiddleware = function (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 = "ResumeProcessesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ScalingProcessQuery.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ResumeProcessesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryResumeProcessesCommand(input, context);
+    };
+    ResumeProcessesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryResumeProcessesCommand(output, context);
+    };
+    return ResumeProcessesCommand;
+}($Command));
+export { ResumeProcessesCommand };

package/dist-es/commands/SetDesiredCapacityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { SetDesiredCapacityType } from "../models/models_0";
+import { deserializeAws_querySetDesiredCapacityCommand, serializeAws_querySetDesiredCapacityCommand, } from "../protocols/Aws_query";
+var SetDesiredCapacityCommand = (function (_super) {
+    __extends(SetDesiredCapacityCommand, _super);
+    function SetDesiredCapacityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetDesiredCapacityCommand.prototype.resolveMiddleware = function (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 = "SetDesiredCapacityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetDesiredCapacityType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetDesiredCapacityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetDesiredCapacityCommand(input, context);
+    };
+    SetDesiredCapacityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetDesiredCapacityCommand(output, context);
+    };
+    return SetDesiredCapacityCommand;
+}($Command));
+export { SetDesiredCapacityCommand };

package/dist-es/commands/SetInstanceHealthCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { SetInstanceHealthQuery } from "../models/models_0";
+import { deserializeAws_querySetInstanceHealthCommand, serializeAws_querySetInstanceHealthCommand, } from "../protocols/Aws_query";
+var SetInstanceHealthCommand = (function (_super) {
+    __extends(SetInstanceHealthCommand, _super);
+    function SetInstanceHealthCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetInstanceHealthCommand.prototype.resolveMiddleware = function (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 = "SetInstanceHealthCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetInstanceHealthQuery.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetInstanceHealthCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetInstanceHealthCommand(input, context);
+    };
+    SetInstanceHealthCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetInstanceHealthCommand(output, context);
+    };
+    return SetInstanceHealthCommand;
+}($Command));
+export { SetInstanceHealthCommand };

package/dist-es/commands/SetInstanceProtectionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { SetInstanceProtectionAnswer, SetInstanceProtectionQuery } from "../models/models_0";
+import { deserializeAws_querySetInstanceProtectionCommand, serializeAws_querySetInstanceProtectionCommand, } from "../protocols/Aws_query";
+var SetInstanceProtectionCommand = (function (_super) {
+    __extends(SetInstanceProtectionCommand, _super);
+    function SetInstanceProtectionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetInstanceProtectionCommand.prototype.resolveMiddleware = function (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 = "SetInstanceProtectionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetInstanceProtectionQuery.filterSensitiveLog,
+            outputFilterSensitiveLog: SetInstanceProtectionAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetInstanceProtectionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetInstanceProtectionCommand(input, context);
+    };
+    SetInstanceProtectionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetInstanceProtectionCommand(output, context);
+    };
+    return SetInstanceProtectionCommand;
+}($Command));
+export { SetInstanceProtectionCommand };

package/dist-es/commands/StartInstanceRefreshCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartInstanceRefreshAnswer, StartInstanceRefreshType } from "../models/models_0";
+import { deserializeAws_queryStartInstanceRefreshCommand, serializeAws_queryStartInstanceRefreshCommand, } from "../protocols/Aws_query";
+var StartInstanceRefreshCommand = (function (_super) {
+    __extends(StartInstanceRefreshCommand, _super);
+    function StartInstanceRefreshCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StartInstanceRefreshCommand.prototype.resolveMiddleware = function (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 = "StartInstanceRefreshCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StartInstanceRefreshType.filterSensitiveLog,
+            outputFilterSensitiveLog: StartInstanceRefreshAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartInstanceRefreshCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryStartInstanceRefreshCommand(input, context);
+    };
+    StartInstanceRefreshCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryStartInstanceRefreshCommand(output, context);
+    };
+    return StartInstanceRefreshCommand;
+}($Command));
+export { StartInstanceRefreshCommand };

package/dist-es/commands/SuspendProcessesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ScalingProcessQuery } from "../models/models_0";
+import { deserializeAws_querySuspendProcessesCommand, serializeAws_querySuspendProcessesCommand, } from "../protocols/Aws_query";
+var SuspendProcessesCommand = (function (_super) {
+    __extends(SuspendProcessesCommand, _super);
+    function SuspendProcessesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SuspendProcessesCommand.prototype.resolveMiddleware = function (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 = "SuspendProcessesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ScalingProcessQuery.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SuspendProcessesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySuspendProcessesCommand(input, context);
+    };
+    SuspendProcessesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySuspendProcessesCommand(output, context);
+    };
+    return SuspendProcessesCommand;
+}($Command));
+export { SuspendProcessesCommand };

package/dist-es/commands/TerminateInstanceInAutoScalingGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ActivityType, TerminateInstanceInAutoScalingGroupType } from "../models/models_0";
+import { deserializeAws_queryTerminateInstanceInAutoScalingGroupCommand, serializeAws_queryTerminateInstanceInAutoScalingGroupCommand, } from "../protocols/Aws_query";
+var TerminateInstanceInAutoScalingGroupCommand = (function (_super) {
+    __extends(TerminateInstanceInAutoScalingGroupCommand, _super);
+    function TerminateInstanceInAutoScalingGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TerminateInstanceInAutoScalingGroupCommand.prototype.resolveMiddleware = function (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 = "TerminateInstanceInAutoScalingGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TerminateInstanceInAutoScalingGroupType.filterSensitiveLog,
+            outputFilterSensitiveLog: ActivityType.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TerminateInstanceInAutoScalingGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryTerminateInstanceInAutoScalingGroupCommand(input, context);
+    };
+    TerminateInstanceInAutoScalingGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryTerminateInstanceInAutoScalingGroupCommand(output, context);
+    };
+    return TerminateInstanceInAutoScalingGroupCommand;
+}($Command));
+export { TerminateInstanceInAutoScalingGroupCommand };

package/dist-es/commands/UpdateAutoScalingGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateAutoScalingGroupType } from "../models/models_0";
+import { deserializeAws_queryUpdateAutoScalingGroupCommand, serializeAws_queryUpdateAutoScalingGroupCommand, } from "../protocols/Aws_query";
+var UpdateAutoScalingGroupCommand = (function (_super) {
+    __extends(UpdateAutoScalingGroupCommand, _super);
+    function UpdateAutoScalingGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateAutoScalingGroupCommand.prototype.resolveMiddleware = function (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 = "UpdateAutoScalingGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateAutoScalingGroupType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateAutoScalingGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateAutoScalingGroupCommand(input, context);
+    };
+    UpdateAutoScalingGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateAutoScalingGroupCommand(output, context);
+    };
+    return UpdateAutoScalingGroupCommand;
+}($Command));
+export { UpdateAutoScalingGroupCommand };

package/dist-es/endpoints.js

@@ -0,0 +1,52 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { getRegionInfo } from "@aws-sdk/config-resolver";
+var regionHash = {};
+var partitionHash = {
+    aws: {
+        regions: [
+            "af-south-1",
+            "ap-east-1",
+            "ap-northeast-1",
+            "ap-northeast-2",
+            "ap-northeast-3",
+            "ap-south-1",
+            "ap-southeast-1",
+            "ap-southeast-2",
+            "ca-central-1",
+            "eu-central-1",
+            "eu-north-1",
+            "eu-south-1",
+            "eu-west-1",
+            "eu-west-2",
+            "eu-west-3",
+            "me-south-1",
+            "sa-east-1",
+            "us-east-1",
+            "us-east-2",
+            "us-west-1",
+            "us-west-2",
+        ],
+        hostname: "autoscaling.{region}.amazonaws.com",
+    },
+    "aws-cn": {
+        regions: ["cn-north-1", "cn-northwest-1"],
+        hostname: "autoscaling.{region}.amazonaws.com.cn",
+    },
+    "aws-iso": {
+        regions: ["us-iso-east-1"],
+        hostname: "autoscaling.{region}.c2s.ic.gov",
+    },
+    "aws-iso-b": {
+        regions: ["us-isob-east-1"],
+        hostname: "autoscaling.{region}.sc2s.sgov.gov",
+    },
+    "aws-us-gov": {
+        regions: ["us-gov-east-1", "us-gov-west-1"],
+        hostname: "autoscaling.{region}.amazonaws.com",
+    },
+};
+export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "autoscaling", regionHash: regionHash, partitionHash: partitionHash }))];
+    });
+}); };