@aws-sdk/client-lightsail 3.183.0 → 3.185.0

package/dist-es/commands/GetRelationalDatabaseBlueprintsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseBlueprintsRequestFilterSensitiveLog, GetRelationalDatabaseBlueprintsResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseBlueprintsCommand, serializeAws_json1_1GetRelationalDatabaseBlueprintsCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseBlueprintsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseBlueprintsCommand = (function (_super) {
+    __extends(GetRelationalDatabaseBlueprintsCommand, _super);
+    function GetRelationalDatabaseBlueprintsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseBlueprintsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseBlueprintsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRelationalDatabaseBlueprintsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseBlueprintsResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseBlueprintsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseBlueprintsCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseBlueprintsCommand;
+}($Command));
+export { GetRelationalDatabaseBlueprintsCommand };

package/dist-es/commands/GetRelationalDatabaseBundlesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseBundlesRequestFilterSensitiveLog, GetRelationalDatabaseBundlesResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseBundlesCommand, serializeAws_json1_1GetRelationalDatabaseBundlesCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseBundlesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseBundlesCommand = (function (_super) {
+    __extends(GetRelationalDatabaseBundlesCommand, _super);
+    function GetRelationalDatabaseBundlesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseBundlesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseBundlesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRelationalDatabaseBundlesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseBundlesResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseBundlesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseBundlesCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseBundlesCommand;
+}($Command));
+export { GetRelationalDatabaseBundlesCommand };

package/dist-es/commands/GetRelationalDatabaseCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseRequestFilterSensitiveLog, GetRelationalDatabaseResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseCommand, serializeAws_json1_1GetRelationalDatabaseCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseCommand = (function (_super) {
+    __extends(GetRelationalDatabaseCommand, _super);
+    function GetRelationalDatabaseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: GetRelationalDatabaseRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseCommand;
+}($Command));
+export { GetRelationalDatabaseCommand };

package/dist-es/commands/GetRelationalDatabaseEventsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseEventsRequestFilterSensitiveLog, GetRelationalDatabaseEventsResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseEventsCommand, serializeAws_json1_1GetRelationalDatabaseEventsCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseEventsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseEventsCommand = (function (_super) {
+    __extends(GetRelationalDatabaseEventsCommand, _super);
+    function GetRelationalDatabaseEventsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseEventsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseEventsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "GetRelationalDatabaseEventsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetRelationalDatabaseEventsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseEventsResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRelationalDatabaseEventsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRelationalDatabaseEventsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseEventsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseEventsCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseEventsCommand;
+}($Command));
+export { GetRelationalDatabaseEventsCommand };

package/dist-es/commands/GetRelationalDatabaseLogEventsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseLogEventsRequestFilterSensitiveLog, GetRelationalDatabaseLogEventsResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseLogEventsCommand, serializeAws_json1_1GetRelationalDatabaseLogEventsCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseLogEventsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseLogEventsCommand = (function (_super) {
+    __extends(GetRelationalDatabaseLogEventsCommand, _super);
+    function GetRelationalDatabaseLogEventsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseLogEventsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseLogEventsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "GetRelationalDatabaseLogEventsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetRelationalDatabaseLogEventsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseLogEventsResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRelationalDatabaseLogEventsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRelationalDatabaseLogEventsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseLogEventsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseLogEventsCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseLogEventsCommand;
+}($Command));
+export { GetRelationalDatabaseLogEventsCommand };

package/dist-es/commands/GetRelationalDatabaseLogStreamsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseLogStreamsRequestFilterSensitiveLog, GetRelationalDatabaseLogStreamsResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseLogStreamsCommand, serializeAws_json1_1GetRelationalDatabaseLogStreamsCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseLogStreamsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseLogStreamsCommand = (function (_super) {
+    __extends(GetRelationalDatabaseLogStreamsCommand, _super);
+    function GetRelationalDatabaseLogStreamsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseLogStreamsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseLogStreamsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "GetRelationalDatabaseLogStreamsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetRelationalDatabaseLogStreamsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseLogStreamsResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRelationalDatabaseLogStreamsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRelationalDatabaseLogStreamsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseLogStreamsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseLogStreamsCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseLogStreamsCommand;
+}($Command));
+export { GetRelationalDatabaseLogStreamsCommand };

package/dist-es/commands/GetRelationalDatabaseMasterUserPasswordCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseMasterUserPasswordRequestFilterSensitiveLog, GetRelationalDatabaseMasterUserPasswordResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseMasterUserPasswordCommand, serializeAws_json1_1GetRelationalDatabaseMasterUserPasswordCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseMasterUserPasswordCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseMasterUserPasswordCommand = (function (_super) {
+    __extends(GetRelationalDatabaseMasterUserPasswordCommand, _super);
+    function GetRelationalDatabaseMasterUserPasswordCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseMasterUserPasswordCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseMasterUserPasswordCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "GetRelationalDatabaseMasterUserPasswordCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetRelationalDatabaseMasterUserPasswordRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseMasterUserPasswordResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRelationalDatabaseMasterUserPasswordCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRelationalDatabaseMasterUserPasswordCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseMasterUserPasswordCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseMasterUserPasswordCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseMasterUserPasswordCommand;
+}($Command));
+export { GetRelationalDatabaseMasterUserPasswordCommand };

package/dist-es/commands/GetRelationalDatabaseMetricDataCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseMetricDataRequestFilterSensitiveLog, GetRelationalDatabaseMetricDataResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseMetricDataCommand, serializeAws_json1_1GetRelationalDatabaseMetricDataCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseMetricDataCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseMetricDataCommand = (function (_super) {
+    __extends(GetRelationalDatabaseMetricDataCommand, _super);
+    function GetRelationalDatabaseMetricDataCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseMetricDataCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseMetricDataCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "GetRelationalDatabaseMetricDataCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetRelationalDatabaseMetricDataRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseMetricDataResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRelationalDatabaseMetricDataCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRelationalDatabaseMetricDataCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseMetricDataCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseMetricDataCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseMetricDataCommand;
+}($Command));
+export { GetRelationalDatabaseMetricDataCommand };

package/dist-es/commands/GetRelationalDatabaseParametersCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseParametersRequestFilterSensitiveLog, GetRelationalDatabaseParametersResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseParametersCommand, serializeAws_json1_1GetRelationalDatabaseParametersCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseParametersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseParametersCommand = (function (_super) {
+    __extends(GetRelationalDatabaseParametersCommand, _super);
+    function GetRelationalDatabaseParametersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseParametersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseParametersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "GetRelationalDatabaseParametersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetRelationalDatabaseParametersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseParametersResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRelationalDatabaseParametersCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRelationalDatabaseParametersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseParametersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseParametersCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseParametersCommand;
+}($Command));
+export { GetRelationalDatabaseParametersCommand };

package/dist-es/commands/GetRelationalDatabaseSnapshotCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetRelationalDatabaseSnapshotRequestFilterSensitiveLog, GetRelationalDatabaseSnapshotResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1GetRelationalDatabaseSnapshotCommand, serializeAws_json1_1GetRelationalDatabaseSnapshotCommand, } from "../protocols/Aws_json1_1";
-export class GetRelationalDatabaseSnapshotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetRelationalDatabaseSnapshotCommand = (function (_super) {
+    __extends(GetRelationalDatabaseSnapshotCommand, _super);
+    function GetRelationalDatabaseSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetRelationalDatabaseSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LightsailClient";
-        const commandName = "GetRelationalDatabaseSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "GetRelationalDatabaseSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetRelationalDatabaseSnapshotRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetRelationalDatabaseSnapshotResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetRelationalDatabaseSnapshotCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1GetRelationalDatabaseSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetRelationalDatabaseSnapshotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1GetRelationalDatabaseSnapshotCommand(output, context);
-    }
-}
+    };
+    return GetRelationalDatabaseSnapshotCommand;
+}($Command));
+export { GetRelationalDatabaseSnapshotCommand };