@aws-sdk/client-lightsail 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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