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

package/dist-es/AutoScalingClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var AutoScalingClient = (function (_super) {
+    __extends(AutoScalingClient, _super);
+    function AutoScalingClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    AutoScalingClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return AutoScalingClient;
+}(__Client));
+export { AutoScalingClient };

package/dist-es/commands/AttachInstancesCommand.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 { AttachInstancesQuery } from "../models/models_0";
+import { deserializeAws_queryAttachInstancesCommand, serializeAws_queryAttachInstancesCommand, } from "../protocols/Aws_query";
+var AttachInstancesCommand = (function (_super) {
+    __extends(AttachInstancesCommand, _super);
+    function AttachInstancesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AttachInstancesCommand.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 = "AttachInstancesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AttachInstancesQuery.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AttachInstancesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryAttachInstancesCommand(input, context);
+    };
+    AttachInstancesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryAttachInstancesCommand(output, context);
+    };
+    return AttachInstancesCommand;
+}($Command));
+export { AttachInstancesCommand };

package/dist-es/commands/AttachLoadBalancerTargetGroupsCommand.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 { AttachLoadBalancerTargetGroupsResultType, AttachLoadBalancerTargetGroupsType } from "../models/models_0";
+import { deserializeAws_queryAttachLoadBalancerTargetGroupsCommand, serializeAws_queryAttachLoadBalancerTargetGroupsCommand, } from "../protocols/Aws_query";
+var AttachLoadBalancerTargetGroupsCommand = (function (_super) {
+    __extends(AttachLoadBalancerTargetGroupsCommand, _super);
+    function AttachLoadBalancerTargetGroupsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AttachLoadBalancerTargetGroupsCommand.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 = "AttachLoadBalancerTargetGroupsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AttachLoadBalancerTargetGroupsType.filterSensitiveLog,
+            outputFilterSensitiveLog: AttachLoadBalancerTargetGroupsResultType.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AttachLoadBalancerTargetGroupsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryAttachLoadBalancerTargetGroupsCommand(input, context);
+    };
+    AttachLoadBalancerTargetGroupsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryAttachLoadBalancerTargetGroupsCommand(output, context);
+    };
+    return AttachLoadBalancerTargetGroupsCommand;
+}($Command));
+export { AttachLoadBalancerTargetGroupsCommand };

package/dist-es/commands/AttachLoadBalancersCommand.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 { AttachLoadBalancersResultType, AttachLoadBalancersType } from "../models/models_0";
+import { deserializeAws_queryAttachLoadBalancersCommand, serializeAws_queryAttachLoadBalancersCommand, } from "../protocols/Aws_query";
+var AttachLoadBalancersCommand = (function (_super) {
+    __extends(AttachLoadBalancersCommand, _super);
+    function AttachLoadBalancersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AttachLoadBalancersCommand.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 = "AttachLoadBalancersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AttachLoadBalancersType.filterSensitiveLog,
+            outputFilterSensitiveLog: AttachLoadBalancersResultType.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AttachLoadBalancersCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryAttachLoadBalancersCommand(input, context);
+    };
+    AttachLoadBalancersCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryAttachLoadBalancersCommand(output, context);
+    };
+    return AttachLoadBalancersCommand;
+}($Command));
+export { AttachLoadBalancersCommand };

package/dist-es/commands/BatchDeleteScheduledActionCommand.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 { BatchDeleteScheduledActionAnswer, BatchDeleteScheduledActionType } from "../models/models_0";
+import { deserializeAws_queryBatchDeleteScheduledActionCommand, serializeAws_queryBatchDeleteScheduledActionCommand, } from "../protocols/Aws_query";
+var BatchDeleteScheduledActionCommand = (function (_super) {
+    __extends(BatchDeleteScheduledActionCommand, _super);
+    function BatchDeleteScheduledActionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchDeleteScheduledActionCommand.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 = "BatchDeleteScheduledActionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchDeleteScheduledActionType.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchDeleteScheduledActionAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchDeleteScheduledActionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryBatchDeleteScheduledActionCommand(input, context);
+    };
+    BatchDeleteScheduledActionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryBatchDeleteScheduledActionCommand(output, context);
+    };
+    return BatchDeleteScheduledActionCommand;
+}($Command));
+export { BatchDeleteScheduledActionCommand };

package/dist-es/commands/BatchPutScheduledUpdateGroupActionCommand.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 { BatchPutScheduledUpdateGroupActionAnswer, BatchPutScheduledUpdateGroupActionType } from "../models/models_0";
+import { deserializeAws_queryBatchPutScheduledUpdateGroupActionCommand, serializeAws_queryBatchPutScheduledUpdateGroupActionCommand, } from "../protocols/Aws_query";
+var BatchPutScheduledUpdateGroupActionCommand = (function (_super) {
+    __extends(BatchPutScheduledUpdateGroupActionCommand, _super);
+    function BatchPutScheduledUpdateGroupActionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    BatchPutScheduledUpdateGroupActionCommand.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 = "BatchPutScheduledUpdateGroupActionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: BatchPutScheduledUpdateGroupActionType.filterSensitiveLog,
+            outputFilterSensitiveLog: BatchPutScheduledUpdateGroupActionAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchPutScheduledUpdateGroupActionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryBatchPutScheduledUpdateGroupActionCommand(input, context);
+    };
+    BatchPutScheduledUpdateGroupActionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryBatchPutScheduledUpdateGroupActionCommand(output, context);
+    };
+    return BatchPutScheduledUpdateGroupActionCommand;
+}($Command));
+export { BatchPutScheduledUpdateGroupActionCommand };

package/dist-es/commands/CancelInstanceRefreshCommand.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 { CancelInstanceRefreshAnswer, CancelInstanceRefreshType } from "../models/models_0";
+import { deserializeAws_queryCancelInstanceRefreshCommand, serializeAws_queryCancelInstanceRefreshCommand, } from "../protocols/Aws_query";
+var CancelInstanceRefreshCommand = (function (_super) {
+    __extends(CancelInstanceRefreshCommand, _super);
+    function CancelInstanceRefreshCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CancelInstanceRefreshCommand.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 = "CancelInstanceRefreshCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CancelInstanceRefreshType.filterSensitiveLog,
+            outputFilterSensitiveLog: CancelInstanceRefreshAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CancelInstanceRefreshCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCancelInstanceRefreshCommand(input, context);
+    };
+    CancelInstanceRefreshCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCancelInstanceRefreshCommand(output, context);
+    };
+    return CancelInstanceRefreshCommand;
+}($Command));
+export { CancelInstanceRefreshCommand };

package/dist-es/commands/CompleteLifecycleActionCommand.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 { CompleteLifecycleActionAnswer, CompleteLifecycleActionType } from "../models/models_0";
+import { deserializeAws_queryCompleteLifecycleActionCommand, serializeAws_queryCompleteLifecycleActionCommand, } from "../protocols/Aws_query";
+var CompleteLifecycleActionCommand = (function (_super) {
+    __extends(CompleteLifecycleActionCommand, _super);
+    function CompleteLifecycleActionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CompleteLifecycleActionCommand.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 = "CompleteLifecycleActionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CompleteLifecycleActionType.filterSensitiveLog,
+            outputFilterSensitiveLog: CompleteLifecycleActionAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CompleteLifecycleActionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCompleteLifecycleActionCommand(input, context);
+    };
+    CompleteLifecycleActionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCompleteLifecycleActionCommand(output, context);
+    };
+    return CompleteLifecycleActionCommand;
+}($Command));
+export { CompleteLifecycleActionCommand };

package/dist-es/commands/CreateAutoScalingGroupCommand.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 { CreateAutoScalingGroupType } from "../models/models_0";
+import { deserializeAws_queryCreateAutoScalingGroupCommand, serializeAws_queryCreateAutoScalingGroupCommand, } from "../protocols/Aws_query";
+var CreateAutoScalingGroupCommand = (function (_super) {
+    __extends(CreateAutoScalingGroupCommand, _super);
+    function CreateAutoScalingGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateAutoScalingGroupCommand.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 = "CreateAutoScalingGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateAutoScalingGroupType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateAutoScalingGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateAutoScalingGroupCommand(input, context);
+    };
+    CreateAutoScalingGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateAutoScalingGroupCommand(output, context);
+    };
+    return CreateAutoScalingGroupCommand;
+}($Command));
+export { CreateAutoScalingGroupCommand };

package/dist-es/commands/CreateLaunchConfigurationCommand.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 { CreateLaunchConfigurationType } from "../models/models_0";
+import { deserializeAws_queryCreateLaunchConfigurationCommand, serializeAws_queryCreateLaunchConfigurationCommand, } from "../protocols/Aws_query";
+var CreateLaunchConfigurationCommand = (function (_super) {
+    __extends(CreateLaunchConfigurationCommand, _super);
+    function CreateLaunchConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateLaunchConfigurationCommand.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 = "CreateLaunchConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateLaunchConfigurationType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateLaunchConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateLaunchConfigurationCommand(input, context);
+    };
+    CreateLaunchConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateLaunchConfigurationCommand(output, context);
+    };
+    return CreateLaunchConfigurationCommand;
+}($Command));
+export { CreateLaunchConfigurationCommand };

package/dist-es/commands/CreateOrUpdateTagsCommand.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 { CreateOrUpdateTagsType } from "../models/models_0";
+import { deserializeAws_queryCreateOrUpdateTagsCommand, serializeAws_queryCreateOrUpdateTagsCommand, } from "../protocols/Aws_query";
+var CreateOrUpdateTagsCommand = (function (_super) {
+    __extends(CreateOrUpdateTagsCommand, _super);
+    function CreateOrUpdateTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateOrUpdateTagsCommand.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 = "CreateOrUpdateTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateOrUpdateTagsType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateOrUpdateTagsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateOrUpdateTagsCommand(input, context);
+    };
+    CreateOrUpdateTagsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateOrUpdateTagsCommand(output, context);
+    };
+    return CreateOrUpdateTagsCommand;
+}($Command));
+export { CreateOrUpdateTagsCommand };

package/dist-es/commands/DeleteAutoScalingGroupCommand.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 { DeleteAutoScalingGroupType } from "../models/models_0";
+import { deserializeAws_queryDeleteAutoScalingGroupCommand, serializeAws_queryDeleteAutoScalingGroupCommand, } from "../protocols/Aws_query";
+var DeleteAutoScalingGroupCommand = (function (_super) {
+    __extends(DeleteAutoScalingGroupCommand, _super);
+    function DeleteAutoScalingGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteAutoScalingGroupCommand.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 = "DeleteAutoScalingGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteAutoScalingGroupType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteAutoScalingGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDeleteAutoScalingGroupCommand(input, context);
+    };
+    DeleteAutoScalingGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDeleteAutoScalingGroupCommand(output, context);
+    };
+    return DeleteAutoScalingGroupCommand;
+}($Command));
+export { DeleteAutoScalingGroupCommand };

package/dist-es/commands/DeleteLaunchConfigurationCommand.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 { LaunchConfigurationNameType } from "../models/models_0";
+import { deserializeAws_queryDeleteLaunchConfigurationCommand, serializeAws_queryDeleteLaunchConfigurationCommand, } from "../protocols/Aws_query";
+var DeleteLaunchConfigurationCommand = (function (_super) {
+    __extends(DeleteLaunchConfigurationCommand, _super);
+    function DeleteLaunchConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteLaunchConfigurationCommand.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 = "DeleteLaunchConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: LaunchConfigurationNameType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteLaunchConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDeleteLaunchConfigurationCommand(input, context);
+    };
+    DeleteLaunchConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDeleteLaunchConfigurationCommand(output, context);
+    };
+    return DeleteLaunchConfigurationCommand;
+}($Command));
+export { DeleteLaunchConfigurationCommand };

package/dist-es/commands/DeleteLifecycleHookCommand.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 { DeleteLifecycleHookAnswer, DeleteLifecycleHookType } from "../models/models_0";
+import { deserializeAws_queryDeleteLifecycleHookCommand, serializeAws_queryDeleteLifecycleHookCommand, } from "../protocols/Aws_query";
+var DeleteLifecycleHookCommand = (function (_super) {
+    __extends(DeleteLifecycleHookCommand, _super);
+    function DeleteLifecycleHookCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteLifecycleHookCommand.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 = "DeleteLifecycleHookCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteLifecycleHookType.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteLifecycleHookAnswer.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteLifecycleHookCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDeleteLifecycleHookCommand(input, context);
+    };
+    DeleteLifecycleHookCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDeleteLifecycleHookCommand(output, context);
+    };
+    return DeleteLifecycleHookCommand;
+}($Command));
+export { DeleteLifecycleHookCommand };

package/dist-es/commands/DeleteNotificationConfigurationCommand.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 { DeleteNotificationConfigurationType } from "../models/models_0";
+import { deserializeAws_queryDeleteNotificationConfigurationCommand, serializeAws_queryDeleteNotificationConfigurationCommand, } from "../protocols/Aws_query";
+var DeleteNotificationConfigurationCommand = (function (_super) {
+    __extends(DeleteNotificationConfigurationCommand, _super);
+    function DeleteNotificationConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteNotificationConfigurationCommand.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 = "DeleteNotificationConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteNotificationConfigurationType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteNotificationConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDeleteNotificationConfigurationCommand(input, context);
+    };
+    DeleteNotificationConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDeleteNotificationConfigurationCommand(output, context);
+    };
+    return DeleteNotificationConfigurationCommand;
+}($Command));
+export { DeleteNotificationConfigurationCommand };

package/dist-es/commands/DeletePolicyCommand.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 { DeletePolicyType } from "../models/models_0";
+import { deserializeAws_queryDeletePolicyCommand, serializeAws_queryDeletePolicyCommand } from "../protocols/Aws_query";
+var DeletePolicyCommand = (function (_super) {
+    __extends(DeletePolicyCommand, _super);
+    function DeletePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeletePolicyCommand.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 = "DeletePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeletePolicyType.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeletePolicyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDeletePolicyCommand(input, context);
+    };
+    DeletePolicyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDeletePolicyCommand(output, context);
+    };
+    return DeletePolicyCommand;
+}($Command));
+export { DeletePolicyCommand };