@aws-sdk/client-lightsail 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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