@aws-sdk/client-lightsail 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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