@aws-sdk/client-lightsail 3.32.0 → 3.36.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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