@aws-sdk/client-lightsail 3.183.0 → 3.186.0

package/dist-es/commands/RebootInstanceCommand.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 { RebootInstanceRequestFilterSensitiveLog, RebootInstanceResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1RebootInstanceCommand, serializeAws_json1_1RebootInstanceCommand, } from "../protocols/Aws_json1_1";
-export class RebootInstanceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RebootInstanceCommand = (function (_super) {
+    __extends(RebootInstanceCommand, _super);
+    function RebootInstanceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RebootInstanceCommand.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 = "RebootInstanceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "RebootInstanceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RebootInstanceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RebootInstanceResultFilterSensitiveLog,
         };
-        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);
+    };
+    RebootInstanceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1RebootInstanceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RebootInstanceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1RebootInstanceCommand(output, context);
-    }
-}
+    };
+    return RebootInstanceCommand;
+}($Command));
+export { RebootInstanceCommand };

package/dist-es/commands/RebootRelationalDatabaseCommand.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 { RebootRelationalDatabaseRequestFilterSensitiveLog, RebootRelationalDatabaseResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1RebootRelationalDatabaseCommand, serializeAws_json1_1RebootRelationalDatabaseCommand, } from "../protocols/Aws_json1_1";
-export class RebootRelationalDatabaseCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RebootRelationalDatabaseCommand = (function (_super) {
+    __extends(RebootRelationalDatabaseCommand, _super);
+    function RebootRelationalDatabaseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RebootRelationalDatabaseCommand.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 = "RebootRelationalDatabaseCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "RebootRelationalDatabaseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RebootRelationalDatabaseRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RebootRelationalDatabaseResultFilterSensitiveLog,
         };
-        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);
+    };
+    RebootRelationalDatabaseCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1RebootRelationalDatabaseCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RebootRelationalDatabaseCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1RebootRelationalDatabaseCommand(output, context);
-    }
-}
+    };
+    return RebootRelationalDatabaseCommand;
+}($Command));
+export { RebootRelationalDatabaseCommand };

package/dist-es/commands/RegisterContainerImageCommand.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 { RegisterContainerImageRequestFilterSensitiveLog, RegisterContainerImageResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1RegisterContainerImageCommand, serializeAws_json1_1RegisterContainerImageCommand, } from "../protocols/Aws_json1_1";
-export class RegisterContainerImageCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RegisterContainerImageCommand = (function (_super) {
+    __extends(RegisterContainerImageCommand, _super);
+    function RegisterContainerImageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RegisterContainerImageCommand.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 = "RegisterContainerImageCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "RegisterContainerImageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RegisterContainerImageRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RegisterContainerImageResultFilterSensitiveLog,
         };
-        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);
+    };
+    RegisterContainerImageCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1RegisterContainerImageCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RegisterContainerImageCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1RegisterContainerImageCommand(output, context);
-    }
-}
+    };
+    return RegisterContainerImageCommand;
+}($Command));
+export { RegisterContainerImageCommand };

package/dist-es/commands/ReleaseStaticIpCommand.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 { ReleaseStaticIpRequestFilterSensitiveLog, ReleaseStaticIpResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1ReleaseStaticIpCommand, serializeAws_json1_1ReleaseStaticIpCommand, } from "../protocols/Aws_json1_1";
-export class ReleaseStaticIpCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ReleaseStaticIpCommand = (function (_super) {
+    __extends(ReleaseStaticIpCommand, _super);
+    function ReleaseStaticIpCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ReleaseStaticIpCommand.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 = "ReleaseStaticIpCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "ReleaseStaticIpCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ReleaseStaticIpRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ReleaseStaticIpResultFilterSensitiveLog,
         };
-        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);
+    };
+    ReleaseStaticIpCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ReleaseStaticIpCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ReleaseStaticIpCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ReleaseStaticIpCommand(output, context);
-    }
-}
+    };
+    return ReleaseStaticIpCommand;
+}($Command));
+export { ReleaseStaticIpCommand };

package/dist-es/commands/ResetDistributionCacheCommand.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 { ResetDistributionCacheRequestFilterSensitiveLog, ResetDistributionCacheResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1ResetDistributionCacheCommand, serializeAws_json1_1ResetDistributionCacheCommand, } from "../protocols/Aws_json1_1";
-export class ResetDistributionCacheCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ResetDistributionCacheCommand = (function (_super) {
+    __extends(ResetDistributionCacheCommand, _super);
+    function ResetDistributionCacheCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ResetDistributionCacheCommand.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 = "ResetDistributionCacheCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "ResetDistributionCacheCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ResetDistributionCacheRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ResetDistributionCacheResultFilterSensitiveLog,
         };
-        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);
+    };
+    ResetDistributionCacheCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ResetDistributionCacheCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ResetDistributionCacheCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ResetDistributionCacheCommand(output, context);
-    }
-}
+    };
+    return ResetDistributionCacheCommand;
+}($Command));
+export { ResetDistributionCacheCommand };

package/dist-es/commands/SendContactMethodVerificationCommand.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 { SendContactMethodVerificationRequestFilterSensitiveLog, SendContactMethodVerificationResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1SendContactMethodVerificationCommand, serializeAws_json1_1SendContactMethodVerificationCommand, } from "../protocols/Aws_json1_1";
-export class SendContactMethodVerificationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SendContactMethodVerificationCommand = (function (_super) {
+    __extends(SendContactMethodVerificationCommand, _super);
+    function SendContactMethodVerificationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SendContactMethodVerificationCommand.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 = "SendContactMethodVerificationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "SendContactMethodVerificationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SendContactMethodVerificationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SendContactMethodVerificationResultFilterSensitiveLog,
         };
-        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);
+    };
+    SendContactMethodVerificationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1SendContactMethodVerificationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SendContactMethodVerificationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1SendContactMethodVerificationCommand(output, context);
-    }
-}
+    };
+    return SendContactMethodVerificationCommand;
+}($Command));
+export { SendContactMethodVerificationCommand };

package/dist-es/commands/SetIpAddressTypeCommand.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 { SetIpAddressTypeRequestFilterSensitiveLog, SetIpAddressTypeResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1SetIpAddressTypeCommand, serializeAws_json1_1SetIpAddressTypeCommand, } from "../protocols/Aws_json1_1";
-export class SetIpAddressTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SetIpAddressTypeCommand = (function (_super) {
+    __extends(SetIpAddressTypeCommand, _super);
+    function SetIpAddressTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SetIpAddressTypeCommand.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 = "SetIpAddressTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "SetIpAddressTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SetIpAddressTypeRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetIpAddressTypeResultFilterSensitiveLog,
         };
-        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);
+    };
+    SetIpAddressTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1SetIpAddressTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SetIpAddressTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1SetIpAddressTypeCommand(output, context);
-    }
-}
+    };
+    return SetIpAddressTypeCommand;
+}($Command));
+export { SetIpAddressTypeCommand };

package/dist-es/commands/SetResourceAccessForBucketCommand.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 { SetResourceAccessForBucketRequestFilterSensitiveLog, SetResourceAccessForBucketResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1SetResourceAccessForBucketCommand, serializeAws_json1_1SetResourceAccessForBucketCommand, } from "../protocols/Aws_json1_1";
-export class SetResourceAccessForBucketCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SetResourceAccessForBucketCommand = (function (_super) {
+    __extends(SetResourceAccessForBucketCommand, _super);
+    function SetResourceAccessForBucketCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SetResourceAccessForBucketCommand.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 = "SetResourceAccessForBucketCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "SetResourceAccessForBucketCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SetResourceAccessForBucketRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetResourceAccessForBucketResultFilterSensitiveLog,
         };
-        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);
+    };
+    SetResourceAccessForBucketCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1SetResourceAccessForBucketCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SetResourceAccessForBucketCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1SetResourceAccessForBucketCommand(output, context);
-    }
-}
+    };
+    return SetResourceAccessForBucketCommand;
+}($Command));
+export { SetResourceAccessForBucketCommand };

package/dist-es/commands/StartInstanceCommand.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 { StartInstanceRequestFilterSensitiveLog, StartInstanceResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1StartInstanceCommand, serializeAws_json1_1StartInstanceCommand, } from "../protocols/Aws_json1_1";
-export class StartInstanceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartInstanceCommand = (function (_super) {
+    __extends(StartInstanceCommand, _super);
+    function StartInstanceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartInstanceCommand.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 = "StartInstanceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "StartInstanceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartInstanceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartInstanceResultFilterSensitiveLog,
         };
-        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);
+    };
+    StartInstanceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartInstanceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartInstanceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartInstanceCommand(output, context);
-    }
-}
+    };
+    return StartInstanceCommand;
+}($Command));
+export { StartInstanceCommand };

package/dist-es/commands/StartRelationalDatabaseCommand.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 { StartRelationalDatabaseRequestFilterSensitiveLog, StartRelationalDatabaseResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_json1_1StartRelationalDatabaseCommand, serializeAws_json1_1StartRelationalDatabaseCommand, } from "../protocols/Aws_json1_1";
-export class StartRelationalDatabaseCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartRelationalDatabaseCommand = (function (_super) {
+    __extends(StartRelationalDatabaseCommand, _super);
+    function StartRelationalDatabaseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartRelationalDatabaseCommand.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 = "StartRelationalDatabaseCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LightsailClient";
+        var commandName = "StartRelationalDatabaseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartRelationalDatabaseRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartRelationalDatabaseResultFilterSensitiveLog,
         };
-        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);
+    };
+    StartRelationalDatabaseCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartRelationalDatabaseCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartRelationalDatabaseCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartRelationalDatabaseCommand(output, context);
-    }
-}
+    };
+    return StartRelationalDatabaseCommand;
+}($Command));
+export { StartRelationalDatabaseCommand };