@aws-sdk/client-lightsail 3.32.0 → 3.36.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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