@aws-sdk/client-lightsail 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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