@aws-sdk/client-lightsail 3.183.0 → 3.185.0

package/dist-es/Lightsail.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AllocateStaticIpCommand, } from "./commands/AllocateStaticIpCommand";
 import { AttachCertificateToDistributionCommand, } from "./commands/AttachCertificateToDistributionCommand";
 import { AttachDiskCommand } from "./commands/AttachDiskCommand";
@@ -154,2175 +155,2181 @@ import { UpdateLoadBalancerAttributeCommand, } from "./commands/UpdateLoadBalanc
 import { UpdateRelationalDatabaseCommand, } from "./commands/UpdateRelationalDatabaseCommand";
 import { UpdateRelationalDatabaseParametersCommand, } from "./commands/UpdateRelationalDatabaseParametersCommand";
 import { LightsailClient } from "./LightsailClient";
-export class Lightsail extends LightsailClient {
-    allocateStaticIp(args, optionsOrCb, cb) {
-        const command = new AllocateStaticIpCommand(args);
+var Lightsail = (function (_super) {
+    __extends(Lightsail, _super);
+    function Lightsail() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Lightsail.prototype.allocateStaticIp = function (args, optionsOrCb, cb) {
+        var command = new AllocateStaticIpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    attachCertificateToDistribution(args, optionsOrCb, cb) {
-        const command = new AttachCertificateToDistributionCommand(args);
+    };
+    Lightsail.prototype.attachCertificateToDistribution = function (args, optionsOrCb, cb) {
+        var command = new AttachCertificateToDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    attachDisk(args, optionsOrCb, cb) {
-        const command = new AttachDiskCommand(args);
+    };
+    Lightsail.prototype.attachDisk = function (args, optionsOrCb, cb) {
+        var command = new AttachDiskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    attachInstancesToLoadBalancer(args, optionsOrCb, cb) {
-        const command = new AttachInstancesToLoadBalancerCommand(args);
+    };
+    Lightsail.prototype.attachInstancesToLoadBalancer = function (args, optionsOrCb, cb) {
+        var command = new AttachInstancesToLoadBalancerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    attachLoadBalancerTlsCertificate(args, optionsOrCb, cb) {
-        const command = new AttachLoadBalancerTlsCertificateCommand(args);
+    };
+    Lightsail.prototype.attachLoadBalancerTlsCertificate = function (args, optionsOrCb, cb) {
+        var command = new AttachLoadBalancerTlsCertificateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    attachStaticIp(args, optionsOrCb, cb) {
-        const command = new AttachStaticIpCommand(args);
+    };
+    Lightsail.prototype.attachStaticIp = function (args, optionsOrCb, cb) {
+        var command = new AttachStaticIpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    closeInstancePublicPorts(args, optionsOrCb, cb) {
-        const command = new CloseInstancePublicPortsCommand(args);
+    };
+    Lightsail.prototype.closeInstancePublicPorts = function (args, optionsOrCb, cb) {
+        var command = new CloseInstancePublicPortsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    copySnapshot(args, optionsOrCb, cb) {
-        const command = new CopySnapshotCommand(args);
+    };
+    Lightsail.prototype.copySnapshot = function (args, optionsOrCb, cb) {
+        var command = new CopySnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createBucket(args, optionsOrCb, cb) {
-        const command = new CreateBucketCommand(args);
+    };
+    Lightsail.prototype.createBucket = function (args, optionsOrCb, cb) {
+        var command = new CreateBucketCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createBucketAccessKey(args, optionsOrCb, cb) {
-        const command = new CreateBucketAccessKeyCommand(args);
+    };
+    Lightsail.prototype.createBucketAccessKey = function (args, optionsOrCb, cb) {
+        var command = new CreateBucketAccessKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCertificate(args, optionsOrCb, cb) {
-        const command = new CreateCertificateCommand(args);
+    };
+    Lightsail.prototype.createCertificate = function (args, optionsOrCb, cb) {
+        var command = new CreateCertificateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCloudFormationStack(args, optionsOrCb, cb) {
-        const command = new CreateCloudFormationStackCommand(args);
+    };
+    Lightsail.prototype.createCloudFormationStack = function (args, optionsOrCb, cb) {
+        var command = new CreateCloudFormationStackCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createContactMethod(args, optionsOrCb, cb) {
-        const command = new CreateContactMethodCommand(args);
+    };
+    Lightsail.prototype.createContactMethod = function (args, optionsOrCb, cb) {
+        var command = new CreateContactMethodCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createContainerService(args, optionsOrCb, cb) {
-        const command = new CreateContainerServiceCommand(args);
+    };
+    Lightsail.prototype.createContainerService = function (args, optionsOrCb, cb) {
+        var command = new CreateContainerServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createContainerServiceDeployment(args, optionsOrCb, cb) {
-        const command = new CreateContainerServiceDeploymentCommand(args);
+    };
+    Lightsail.prototype.createContainerServiceDeployment = function (args, optionsOrCb, cb) {
+        var command = new CreateContainerServiceDeploymentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createContainerServiceRegistryLogin(args, optionsOrCb, cb) {
-        const command = new CreateContainerServiceRegistryLoginCommand(args);
+    };
+    Lightsail.prototype.createContainerServiceRegistryLogin = function (args, optionsOrCb, cb) {
+        var command = new CreateContainerServiceRegistryLoginCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDisk(args, optionsOrCb, cb) {
-        const command = new CreateDiskCommand(args);
+    };
+    Lightsail.prototype.createDisk = function (args, optionsOrCb, cb) {
+        var command = new CreateDiskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDiskFromSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateDiskFromSnapshotCommand(args);
+    };
+    Lightsail.prototype.createDiskFromSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateDiskFromSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDiskSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateDiskSnapshotCommand(args);
+    };
+    Lightsail.prototype.createDiskSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateDiskSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDistribution(args, optionsOrCb, cb) {
-        const command = new CreateDistributionCommand(args);
+    };
+    Lightsail.prototype.createDistribution = function (args, optionsOrCb, cb) {
+        var command = new CreateDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDomain(args, optionsOrCb, cb) {
-        const command = new CreateDomainCommand(args);
+    };
+    Lightsail.prototype.createDomain = function (args, optionsOrCb, cb) {
+        var command = new CreateDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDomainEntry(args, optionsOrCb, cb) {
-        const command = new CreateDomainEntryCommand(args);
+    };
+    Lightsail.prototype.createDomainEntry = function (args, optionsOrCb, cb) {
+        var command = new CreateDomainEntryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createInstances(args, optionsOrCb, cb) {
-        const command = new CreateInstancesCommand(args);
+    };
+    Lightsail.prototype.createInstances = function (args, optionsOrCb, cb) {
+        var command = new CreateInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createInstancesFromSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateInstancesFromSnapshotCommand(args);
+    };
+    Lightsail.prototype.createInstancesFromSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateInstancesFromSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createInstanceSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateInstanceSnapshotCommand(args);
+    };
+    Lightsail.prototype.createInstanceSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateInstanceSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createKeyPair(args, optionsOrCb, cb) {
-        const command = new CreateKeyPairCommand(args);
+    };
+    Lightsail.prototype.createKeyPair = function (args, optionsOrCb, cb) {
+        var command = new CreateKeyPairCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createLoadBalancer(args, optionsOrCb, cb) {
-        const command = new CreateLoadBalancerCommand(args);
+    };
+    Lightsail.prototype.createLoadBalancer = function (args, optionsOrCb, cb) {
+        var command = new CreateLoadBalancerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createLoadBalancerTlsCertificate(args, optionsOrCb, cb) {
-        const command = new CreateLoadBalancerTlsCertificateCommand(args);
+    };
+    Lightsail.prototype.createLoadBalancerTlsCertificate = function (args, optionsOrCb, cb) {
+        var command = new CreateLoadBalancerTlsCertificateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createRelationalDatabase(args, optionsOrCb, cb) {
-        const command = new CreateRelationalDatabaseCommand(args);
+    };
+    Lightsail.prototype.createRelationalDatabase = function (args, optionsOrCb, cb) {
+        var command = new CreateRelationalDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createRelationalDatabaseFromSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateRelationalDatabaseFromSnapshotCommand(args);
+    };
+    Lightsail.prototype.createRelationalDatabaseFromSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateRelationalDatabaseFromSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createRelationalDatabaseSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateRelationalDatabaseSnapshotCommand(args);
+    };
+    Lightsail.prototype.createRelationalDatabaseSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateRelationalDatabaseSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAlarm(args, optionsOrCb, cb) {
-        const command = new DeleteAlarmCommand(args);
+    };
+    Lightsail.prototype.deleteAlarm = function (args, optionsOrCb, cb) {
+        var command = new DeleteAlarmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteAutoSnapshot(args, optionsOrCb, cb) {
-        const command = new DeleteAutoSnapshotCommand(args);
+    };
+    Lightsail.prototype.deleteAutoSnapshot = function (args, optionsOrCb, cb) {
+        var command = new DeleteAutoSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBucket(args, optionsOrCb, cb) {
-        const command = new DeleteBucketCommand(args);
+    };
+    Lightsail.prototype.deleteBucket = function (args, optionsOrCb, cb) {
+        var command = new DeleteBucketCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBucketAccessKey(args, optionsOrCb, cb) {
-        const command = new DeleteBucketAccessKeyCommand(args);
+    };
+    Lightsail.prototype.deleteBucketAccessKey = function (args, optionsOrCb, cb) {
+        var command = new DeleteBucketAccessKeyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCertificate(args, optionsOrCb, cb) {
-        const command = new DeleteCertificateCommand(args);
+    };
+    Lightsail.prototype.deleteCertificate = function (args, optionsOrCb, cb) {
+        var command = new DeleteCertificateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteContactMethod(args, optionsOrCb, cb) {
-        const command = new DeleteContactMethodCommand(args);
+    };
+    Lightsail.prototype.deleteContactMethod = function (args, optionsOrCb, cb) {
+        var command = new DeleteContactMethodCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteContainerImage(args, optionsOrCb, cb) {
-        const command = new DeleteContainerImageCommand(args);
+    };
+    Lightsail.prototype.deleteContainerImage = function (args, optionsOrCb, cb) {
+        var command = new DeleteContainerImageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteContainerService(args, optionsOrCb, cb) {
-        const command = new DeleteContainerServiceCommand(args);
+    };
+    Lightsail.prototype.deleteContainerService = function (args, optionsOrCb, cb) {
+        var command = new DeleteContainerServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDisk(args, optionsOrCb, cb) {
-        const command = new DeleteDiskCommand(args);
+    };
+    Lightsail.prototype.deleteDisk = function (args, optionsOrCb, cb) {
+        var command = new DeleteDiskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDiskSnapshot(args, optionsOrCb, cb) {
-        const command = new DeleteDiskSnapshotCommand(args);
+    };
+    Lightsail.prototype.deleteDiskSnapshot = function (args, optionsOrCb, cb) {
+        var command = new DeleteDiskSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDistribution(args, optionsOrCb, cb) {
-        const command = new DeleteDistributionCommand(args);
+    };
+    Lightsail.prototype.deleteDistribution = function (args, optionsOrCb, cb) {
+        var command = new DeleteDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDomain(args, optionsOrCb, cb) {
-        const command = new DeleteDomainCommand(args);
+    };
+    Lightsail.prototype.deleteDomain = function (args, optionsOrCb, cb) {
+        var command = new DeleteDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDomainEntry(args, optionsOrCb, cb) {
-        const command = new DeleteDomainEntryCommand(args);
+    };
+    Lightsail.prototype.deleteDomainEntry = function (args, optionsOrCb, cb) {
+        var command = new DeleteDomainEntryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteInstance(args, optionsOrCb, cb) {
-        const command = new DeleteInstanceCommand(args);
+    };
+    Lightsail.prototype.deleteInstance = function (args, optionsOrCb, cb) {
+        var command = new DeleteInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteInstanceSnapshot(args, optionsOrCb, cb) {
-        const command = new DeleteInstanceSnapshotCommand(args);
+    };
+    Lightsail.prototype.deleteInstanceSnapshot = function (args, optionsOrCb, cb) {
+        var command = new DeleteInstanceSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteKeyPair(args, optionsOrCb, cb) {
-        const command = new DeleteKeyPairCommand(args);
+    };
+    Lightsail.prototype.deleteKeyPair = function (args, optionsOrCb, cb) {
+        var command = new DeleteKeyPairCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteKnownHostKeys(args, optionsOrCb, cb) {
-        const command = new DeleteKnownHostKeysCommand(args);
+    };
+    Lightsail.prototype.deleteKnownHostKeys = function (args, optionsOrCb, cb) {
+        var command = new DeleteKnownHostKeysCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteLoadBalancer(args, optionsOrCb, cb) {
-        const command = new DeleteLoadBalancerCommand(args);
+    };
+    Lightsail.prototype.deleteLoadBalancer = function (args, optionsOrCb, cb) {
+        var command = new DeleteLoadBalancerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteLoadBalancerTlsCertificate(args, optionsOrCb, cb) {
-        const command = new DeleteLoadBalancerTlsCertificateCommand(args);
+    };
+    Lightsail.prototype.deleteLoadBalancerTlsCertificate = function (args, optionsOrCb, cb) {
+        var command = new DeleteLoadBalancerTlsCertificateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteRelationalDatabase(args, optionsOrCb, cb) {
-        const command = new DeleteRelationalDatabaseCommand(args);
+    };
+    Lightsail.prototype.deleteRelationalDatabase = function (args, optionsOrCb, cb) {
+        var command = new DeleteRelationalDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteRelationalDatabaseSnapshot(args, optionsOrCb, cb) {
-        const command = new DeleteRelationalDatabaseSnapshotCommand(args);
+    };
+    Lightsail.prototype.deleteRelationalDatabaseSnapshot = function (args, optionsOrCb, cb) {
+        var command = new DeleteRelationalDatabaseSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detachCertificateFromDistribution(args, optionsOrCb, cb) {
-        const command = new DetachCertificateFromDistributionCommand(args);
+    };
+    Lightsail.prototype.detachCertificateFromDistribution = function (args, optionsOrCb, cb) {
+        var command = new DetachCertificateFromDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detachDisk(args, optionsOrCb, cb) {
-        const command = new DetachDiskCommand(args);
+    };
+    Lightsail.prototype.detachDisk = function (args, optionsOrCb, cb) {
+        var command = new DetachDiskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detachInstancesFromLoadBalancer(args, optionsOrCb, cb) {
-        const command = new DetachInstancesFromLoadBalancerCommand(args);
+    };
+    Lightsail.prototype.detachInstancesFromLoadBalancer = function (args, optionsOrCb, cb) {
+        var command = new DetachInstancesFromLoadBalancerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detachStaticIp(args, optionsOrCb, cb) {
-        const command = new DetachStaticIpCommand(args);
+    };
+    Lightsail.prototype.detachStaticIp = function (args, optionsOrCb, cb) {
+        var command = new DetachStaticIpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disableAddOn(args, optionsOrCb, cb) {
-        const command = new DisableAddOnCommand(args);
+    };
+    Lightsail.prototype.disableAddOn = function (args, optionsOrCb, cb) {
+        var command = new DisableAddOnCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    downloadDefaultKeyPair(args, optionsOrCb, cb) {
-        const command = new DownloadDefaultKeyPairCommand(args);
+    };
+    Lightsail.prototype.downloadDefaultKeyPair = function (args, optionsOrCb, cb) {
+        var command = new DownloadDefaultKeyPairCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    enableAddOn(args, optionsOrCb, cb) {
-        const command = new EnableAddOnCommand(args);
+    };
+    Lightsail.prototype.enableAddOn = function (args, optionsOrCb, cb) {
+        var command = new EnableAddOnCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    exportSnapshot(args, optionsOrCb, cb) {
-        const command = new ExportSnapshotCommand(args);
+    };
+    Lightsail.prototype.exportSnapshot = function (args, optionsOrCb, cb) {
+        var command = new ExportSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getActiveNames(args, optionsOrCb, cb) {
-        const command = new GetActiveNamesCommand(args);
+    };
+    Lightsail.prototype.getActiveNames = function (args, optionsOrCb, cb) {
+        var command = new GetActiveNamesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getAlarms(args, optionsOrCb, cb) {
-        const command = new GetAlarmsCommand(args);
+    };
+    Lightsail.prototype.getAlarms = function (args, optionsOrCb, cb) {
+        var command = new GetAlarmsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getAutoSnapshots(args, optionsOrCb, cb) {
-        const command = new GetAutoSnapshotsCommand(args);
+    };
+    Lightsail.prototype.getAutoSnapshots = function (args, optionsOrCb, cb) {
+        var command = new GetAutoSnapshotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBlueprints(args, optionsOrCb, cb) {
-        const command = new GetBlueprintsCommand(args);
+    };
+    Lightsail.prototype.getBlueprints = function (args, optionsOrCb, cb) {
+        var command = new GetBlueprintsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBucketAccessKeys(args, optionsOrCb, cb) {
-        const command = new GetBucketAccessKeysCommand(args);
+    };
+    Lightsail.prototype.getBucketAccessKeys = function (args, optionsOrCb, cb) {
+        var command = new GetBucketAccessKeysCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBucketBundles(args, optionsOrCb, cb) {
-        const command = new GetBucketBundlesCommand(args);
+    };
+    Lightsail.prototype.getBucketBundles = function (args, optionsOrCb, cb) {
+        var command = new GetBucketBundlesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBucketMetricData(args, optionsOrCb, cb) {
-        const command = new GetBucketMetricDataCommand(args);
+    };
+    Lightsail.prototype.getBucketMetricData = function (args, optionsOrCb, cb) {
+        var command = new GetBucketMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBuckets(args, optionsOrCb, cb) {
-        const command = new GetBucketsCommand(args);
+    };
+    Lightsail.prototype.getBuckets = function (args, optionsOrCb, cb) {
+        var command = new GetBucketsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBundles(args, optionsOrCb, cb) {
-        const command = new GetBundlesCommand(args);
+    };
+    Lightsail.prototype.getBundles = function (args, optionsOrCb, cb) {
+        var command = new GetBundlesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCertificates(args, optionsOrCb, cb) {
-        const command = new GetCertificatesCommand(args);
+    };
+    Lightsail.prototype.getCertificates = function (args, optionsOrCb, cb) {
+        var command = new GetCertificatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCloudFormationStackRecords(args, optionsOrCb, cb) {
-        const command = new GetCloudFormationStackRecordsCommand(args);
+    };
+    Lightsail.prototype.getCloudFormationStackRecords = function (args, optionsOrCb, cb) {
+        var command = new GetCloudFormationStackRecordsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContactMethods(args, optionsOrCb, cb) {
-        const command = new GetContactMethodsCommand(args);
+    };
+    Lightsail.prototype.getContactMethods = function (args, optionsOrCb, cb) {
+        var command = new GetContactMethodsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContainerAPIMetadata(args, optionsOrCb, cb) {
-        const command = new GetContainerAPIMetadataCommand(args);
+    };
+    Lightsail.prototype.getContainerAPIMetadata = function (args, optionsOrCb, cb) {
+        var command = new GetContainerAPIMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContainerImages(args, optionsOrCb, cb) {
-        const command = new GetContainerImagesCommand(args);
+    };
+    Lightsail.prototype.getContainerImages = function (args, optionsOrCb, cb) {
+        var command = new GetContainerImagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContainerLog(args, optionsOrCb, cb) {
-        const command = new GetContainerLogCommand(args);
+    };
+    Lightsail.prototype.getContainerLog = function (args, optionsOrCb, cb) {
+        var command = new GetContainerLogCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContainerServiceDeployments(args, optionsOrCb, cb) {
-        const command = new GetContainerServiceDeploymentsCommand(args);
+    };
+    Lightsail.prototype.getContainerServiceDeployments = function (args, optionsOrCb, cb) {
+        var command = new GetContainerServiceDeploymentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContainerServiceMetricData(args, optionsOrCb, cb) {
-        const command = new GetContainerServiceMetricDataCommand(args);
+    };
+    Lightsail.prototype.getContainerServiceMetricData = function (args, optionsOrCb, cb) {
+        var command = new GetContainerServiceMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContainerServicePowers(args, optionsOrCb, cb) {
-        const command = new GetContainerServicePowersCommand(args);
+    };
+    Lightsail.prototype.getContainerServicePowers = function (args, optionsOrCb, cb) {
+        var command = new GetContainerServicePowersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getContainerServices(args, optionsOrCb, cb) {
-        const command = new GetContainerServicesCommand(args);
+    };
+    Lightsail.prototype.getContainerServices = function (args, optionsOrCb, cb) {
+        var command = new GetContainerServicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDisk(args, optionsOrCb, cb) {
-        const command = new GetDiskCommand(args);
+    };
+    Lightsail.prototype.getDisk = function (args, optionsOrCb, cb) {
+        var command = new GetDiskCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDisks(args, optionsOrCb, cb) {
-        const command = new GetDisksCommand(args);
+    };
+    Lightsail.prototype.getDisks = function (args, optionsOrCb, cb) {
+        var command = new GetDisksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDiskSnapshot(args, optionsOrCb, cb) {
-        const command = new GetDiskSnapshotCommand(args);
+    };
+    Lightsail.prototype.getDiskSnapshot = function (args, optionsOrCb, cb) {
+        var command = new GetDiskSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDiskSnapshots(args, optionsOrCb, cb) {
-        const command = new GetDiskSnapshotsCommand(args);
+    };
+    Lightsail.prototype.getDiskSnapshots = function (args, optionsOrCb, cb) {
+        var command = new GetDiskSnapshotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDistributionBundles(args, optionsOrCb, cb) {
-        const command = new GetDistributionBundlesCommand(args);
+    };
+    Lightsail.prototype.getDistributionBundles = function (args, optionsOrCb, cb) {
+        var command = new GetDistributionBundlesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDistributionLatestCacheReset(args, optionsOrCb, cb) {
-        const command = new GetDistributionLatestCacheResetCommand(args);
+    };
+    Lightsail.prototype.getDistributionLatestCacheReset = function (args, optionsOrCb, cb) {
+        var command = new GetDistributionLatestCacheResetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDistributionMetricData(args, optionsOrCb, cb) {
-        const command = new GetDistributionMetricDataCommand(args);
+    };
+    Lightsail.prototype.getDistributionMetricData = function (args, optionsOrCb, cb) {
+        var command = new GetDistributionMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDistributions(args, optionsOrCb, cb) {
-        const command = new GetDistributionsCommand(args);
+    };
+    Lightsail.prototype.getDistributions = function (args, optionsOrCb, cb) {
+        var command = new GetDistributionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDomain(args, optionsOrCb, cb) {
-        const command = new GetDomainCommand(args);
+    };
+    Lightsail.prototype.getDomain = function (args, optionsOrCb, cb) {
+        var command = new GetDomainCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDomains(args, optionsOrCb, cb) {
-        const command = new GetDomainsCommand(args);
+    };
+    Lightsail.prototype.getDomains = function (args, optionsOrCb, cb) {
+        var command = new GetDomainsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getExportSnapshotRecords(args, optionsOrCb, cb) {
-        const command = new GetExportSnapshotRecordsCommand(args);
+    };
+    Lightsail.prototype.getExportSnapshotRecords = function (args, optionsOrCb, cb) {
+        var command = new GetExportSnapshotRecordsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstance(args, optionsOrCb, cb) {
-        const command = new GetInstanceCommand(args);
+    };
+    Lightsail.prototype.getInstance = function (args, optionsOrCb, cb) {
+        var command = new GetInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstanceAccessDetails(args, optionsOrCb, cb) {
-        const command = new GetInstanceAccessDetailsCommand(args);
+    };
+    Lightsail.prototype.getInstanceAccessDetails = function (args, optionsOrCb, cb) {
+        var command = new GetInstanceAccessDetailsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstanceMetricData(args, optionsOrCb, cb) {
-        const command = new GetInstanceMetricDataCommand(args);
+    };
+    Lightsail.prototype.getInstanceMetricData = function (args, optionsOrCb, cb) {
+        var command = new GetInstanceMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstancePortStates(args, optionsOrCb, cb) {
-        const command = new GetInstancePortStatesCommand(args);
+    };
+    Lightsail.prototype.getInstancePortStates = function (args, optionsOrCb, cb) {
+        var command = new GetInstancePortStatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstances(args, optionsOrCb, cb) {
-        const command = new GetInstancesCommand(args);
+    };
+    Lightsail.prototype.getInstances = function (args, optionsOrCb, cb) {
+        var command = new GetInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstanceSnapshot(args, optionsOrCb, cb) {
-        const command = new GetInstanceSnapshotCommand(args);
+    };
+    Lightsail.prototype.getInstanceSnapshot = function (args, optionsOrCb, cb) {
+        var command = new GetInstanceSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstanceSnapshots(args, optionsOrCb, cb) {
-        const command = new GetInstanceSnapshotsCommand(args);
+    };
+    Lightsail.prototype.getInstanceSnapshots = function (args, optionsOrCb, cb) {
+        var command = new GetInstanceSnapshotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getInstanceState(args, optionsOrCb, cb) {
-        const command = new GetInstanceStateCommand(args);
+    };
+    Lightsail.prototype.getInstanceState = function (args, optionsOrCb, cb) {
+        var command = new GetInstanceStateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getKeyPair(args, optionsOrCb, cb) {
-        const command = new GetKeyPairCommand(args);
+    };
+    Lightsail.prototype.getKeyPair = function (args, optionsOrCb, cb) {
+        var command = new GetKeyPairCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getKeyPairs(args, optionsOrCb, cb) {
-        const command = new GetKeyPairsCommand(args);
+    };
+    Lightsail.prototype.getKeyPairs = function (args, optionsOrCb, cb) {
+        var command = new GetKeyPairsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLoadBalancer(args, optionsOrCb, cb) {
-        const command = new GetLoadBalancerCommand(args);
+    };
+    Lightsail.prototype.getLoadBalancer = function (args, optionsOrCb, cb) {
+        var command = new GetLoadBalancerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLoadBalancerMetricData(args, optionsOrCb, cb) {
-        const command = new GetLoadBalancerMetricDataCommand(args);
+    };
+    Lightsail.prototype.getLoadBalancerMetricData = function (args, optionsOrCb, cb) {
+        var command = new GetLoadBalancerMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLoadBalancers(args, optionsOrCb, cb) {
-        const command = new GetLoadBalancersCommand(args);
+    };
+    Lightsail.prototype.getLoadBalancers = function (args, optionsOrCb, cb) {
+        var command = new GetLoadBalancersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLoadBalancerTlsCertificates(args, optionsOrCb, cb) {
-        const command = new GetLoadBalancerTlsCertificatesCommand(args);
+    };
+    Lightsail.prototype.getLoadBalancerTlsCertificates = function (args, optionsOrCb, cb) {
+        var command = new GetLoadBalancerTlsCertificatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getLoadBalancerTlsPolicies(args, optionsOrCb, cb) {
-        const command = new GetLoadBalancerTlsPoliciesCommand(args);
+    };
+    Lightsail.prototype.getLoadBalancerTlsPolicies = function (args, optionsOrCb, cb) {
+        var command = new GetLoadBalancerTlsPoliciesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getOperation(args, optionsOrCb, cb) {
-        const command = new GetOperationCommand(args);
+    };
+    Lightsail.prototype.getOperation = function (args, optionsOrCb, cb) {
+        var command = new GetOperationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getOperations(args, optionsOrCb, cb) {
-        const command = new GetOperationsCommand(args);
+    };
+    Lightsail.prototype.getOperations = function (args, optionsOrCb, cb) {
+        var command = new GetOperationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getOperationsForResource(args, optionsOrCb, cb) {
-        const command = new GetOperationsForResourceCommand(args);
+    };
+    Lightsail.prototype.getOperationsForResource = function (args, optionsOrCb, cb) {
+        var command = new GetOperationsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRegions(args, optionsOrCb, cb) {
-        const command = new GetRegionsCommand(args);
+    };
+    Lightsail.prototype.getRegions = function (args, optionsOrCb, cb) {
+        var command = new GetRegionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabase(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabase = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseBlueprints(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseBlueprintsCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseBlueprints = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseBlueprintsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseBundles(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseBundlesCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseBundles = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseBundlesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseEvents(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseEventsCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseEvents = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseLogEvents(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseLogEventsCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseLogEvents = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseLogEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseLogStreams(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseLogStreamsCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseLogStreams = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseLogStreamsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseMasterUserPassword(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseMasterUserPasswordCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseMasterUserPassword = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseMasterUserPasswordCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseMetricData(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseMetricDataCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseMetricData = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseMetricDataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseParameters(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseParametersCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseParameters = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseParametersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabases(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabasesCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabases = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseSnapshot(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseSnapshotCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseSnapshot = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseSnapshotCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRelationalDatabaseSnapshots(args, optionsOrCb, cb) {
-        const command = new GetRelationalDatabaseSnapshotsCommand(args);
+    };
+    Lightsail.prototype.getRelationalDatabaseSnapshots = function (args, optionsOrCb, cb) {
+        var command = new GetRelationalDatabaseSnapshotsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getStaticIp(args, optionsOrCb, cb) {
-        const command = new GetStaticIpCommand(args);
+    };
+    Lightsail.prototype.getStaticIp = function (args, optionsOrCb, cb) {
+        var command = new GetStaticIpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getStaticIps(args, optionsOrCb, cb) {
-        const command = new GetStaticIpsCommand(args);
+    };
+    Lightsail.prototype.getStaticIps = function (args, optionsOrCb, cb) {
+        var command = new GetStaticIpsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    importKeyPair(args, optionsOrCb, cb) {
-        const command = new ImportKeyPairCommand(args);
+    };
+    Lightsail.prototype.importKeyPair = function (args, optionsOrCb, cb) {
+        var command = new ImportKeyPairCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    isVpcPeered(args, optionsOrCb, cb) {
-        const command = new IsVpcPeeredCommand(args);
+    };
+    Lightsail.prototype.isVpcPeered = function (args, optionsOrCb, cb) {
+        var command = new IsVpcPeeredCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    openInstancePublicPorts(args, optionsOrCb, cb) {
-        const command = new OpenInstancePublicPortsCommand(args);
+    };
+    Lightsail.prototype.openInstancePublicPorts = function (args, optionsOrCb, cb) {
+        var command = new OpenInstancePublicPortsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    peerVpc(args, optionsOrCb, cb) {
-        const command = new PeerVpcCommand(args);
+    };
+    Lightsail.prototype.peerVpc = function (args, optionsOrCb, cb) {
+        var command = new PeerVpcCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putAlarm(args, optionsOrCb, cb) {
-        const command = new PutAlarmCommand(args);
+    };
+    Lightsail.prototype.putAlarm = function (args, optionsOrCb, cb) {
+        var command = new PutAlarmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putInstancePublicPorts(args, optionsOrCb, cb) {
-        const command = new PutInstancePublicPortsCommand(args);
+    };
+    Lightsail.prototype.putInstancePublicPorts = function (args, optionsOrCb, cb) {
+        var command = new PutInstancePublicPortsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    rebootInstance(args, optionsOrCb, cb) {
-        const command = new RebootInstanceCommand(args);
+    };
+    Lightsail.prototype.rebootInstance = function (args, optionsOrCb, cb) {
+        var command = new RebootInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    rebootRelationalDatabase(args, optionsOrCb, cb) {
-        const command = new RebootRelationalDatabaseCommand(args);
+    };
+    Lightsail.prototype.rebootRelationalDatabase = function (args, optionsOrCb, cb) {
+        var command = new RebootRelationalDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerContainerImage(args, optionsOrCb, cb) {
-        const command = new RegisterContainerImageCommand(args);
+    };
+    Lightsail.prototype.registerContainerImage = function (args, optionsOrCb, cb) {
+        var command = new RegisterContainerImageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    releaseStaticIp(args, optionsOrCb, cb) {
-        const command = new ReleaseStaticIpCommand(args);
+    };
+    Lightsail.prototype.releaseStaticIp = function (args, optionsOrCb, cb) {
+        var command = new ReleaseStaticIpCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    resetDistributionCache(args, optionsOrCb, cb) {
-        const command = new ResetDistributionCacheCommand(args);
+    };
+    Lightsail.prototype.resetDistributionCache = function (args, optionsOrCb, cb) {
+        var command = new ResetDistributionCacheCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    sendContactMethodVerification(args, optionsOrCb, cb) {
-        const command = new SendContactMethodVerificationCommand(args);
+    };
+    Lightsail.prototype.sendContactMethodVerification = function (args, optionsOrCb, cb) {
+        var command = new SendContactMethodVerificationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    setIpAddressType(args, optionsOrCb, cb) {
-        const command = new SetIpAddressTypeCommand(args);
+    };
+    Lightsail.prototype.setIpAddressType = function (args, optionsOrCb, cb) {
+        var command = new SetIpAddressTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    setResourceAccessForBucket(args, optionsOrCb, cb) {
-        const command = new SetResourceAccessForBucketCommand(args);
+    };
+    Lightsail.prototype.setResourceAccessForBucket = function (args, optionsOrCb, cb) {
+        var command = new SetResourceAccessForBucketCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startInstance(args, optionsOrCb, cb) {
-        const command = new StartInstanceCommand(args);
+    };
+    Lightsail.prototype.startInstance = function (args, optionsOrCb, cb) {
+        var command = new StartInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startRelationalDatabase(args, optionsOrCb, cb) {
-        const command = new StartRelationalDatabaseCommand(args);
+    };
+    Lightsail.prototype.startRelationalDatabase = function (args, optionsOrCb, cb) {
+        var command = new StartRelationalDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopInstance(args, optionsOrCb, cb) {
-        const command = new StopInstanceCommand(args);
+    };
+    Lightsail.prototype.stopInstance = function (args, optionsOrCb, cb) {
+        var command = new StopInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopRelationalDatabase(args, optionsOrCb, cb) {
-        const command = new StopRelationalDatabaseCommand(args);
+    };
+    Lightsail.prototype.stopRelationalDatabase = function (args, optionsOrCb, cb) {
+        var command = new StopRelationalDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    Lightsail.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    testAlarm(args, optionsOrCb, cb) {
-        const command = new TestAlarmCommand(args);
+    };
+    Lightsail.prototype.testAlarm = function (args, optionsOrCb, cb) {
+        var command = new TestAlarmCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    unpeerVpc(args, optionsOrCb, cb) {
-        const command = new UnpeerVpcCommand(args);
+    };
+    Lightsail.prototype.unpeerVpc = function (args, optionsOrCb, cb) {
+        var command = new UnpeerVpcCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    Lightsail.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBucket(args, optionsOrCb, cb) {
-        const command = new UpdateBucketCommand(args);
+    };
+    Lightsail.prototype.updateBucket = function (args, optionsOrCb, cb) {
+        var command = new UpdateBucketCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBucketBundle(args, optionsOrCb, cb) {
-        const command = new UpdateBucketBundleCommand(args);
+    };
+    Lightsail.prototype.updateBucketBundle = function (args, optionsOrCb, cb) {
+        var command = new UpdateBucketBundleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateContainerService(args, optionsOrCb, cb) {
-        const command = new UpdateContainerServiceCommand(args);
+    };
+    Lightsail.prototype.updateContainerService = function (args, optionsOrCb, cb) {
+        var command = new UpdateContainerServiceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDistribution(args, optionsOrCb, cb) {
-        const command = new UpdateDistributionCommand(args);
+    };
+    Lightsail.prototype.updateDistribution = function (args, optionsOrCb, cb) {
+        var command = new UpdateDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDistributionBundle(args, optionsOrCb, cb) {
-        const command = new UpdateDistributionBundleCommand(args);
+    };
+    Lightsail.prototype.updateDistributionBundle = function (args, optionsOrCb, cb) {
+        var command = new UpdateDistributionBundleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDomainEntry(args, optionsOrCb, cb) {
-        const command = new UpdateDomainEntryCommand(args);
+    };
+    Lightsail.prototype.updateDomainEntry = function (args, optionsOrCb, cb) {
+        var command = new UpdateDomainEntryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateInstanceMetadataOptions(args, optionsOrCb, cb) {
-        const command = new UpdateInstanceMetadataOptionsCommand(args);
+    };
+    Lightsail.prototype.updateInstanceMetadataOptions = function (args, optionsOrCb, cb) {
+        var command = new UpdateInstanceMetadataOptionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateLoadBalancerAttribute(args, optionsOrCb, cb) {
-        const command = new UpdateLoadBalancerAttributeCommand(args);
+    };
+    Lightsail.prototype.updateLoadBalancerAttribute = function (args, optionsOrCb, cb) {
+        var command = new UpdateLoadBalancerAttributeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateRelationalDatabase(args, optionsOrCb, cb) {
-        const command = new UpdateRelationalDatabaseCommand(args);
+    };
+    Lightsail.prototype.updateRelationalDatabase = function (args, optionsOrCb, cb) {
+        var command = new UpdateRelationalDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateRelationalDatabaseParameters(args, optionsOrCb, cb) {
-        const command = new UpdateRelationalDatabaseParametersCommand(args);
+    };
+    Lightsail.prototype.updateRelationalDatabaseParameters = function (args, optionsOrCb, cb) {
+        var command = new UpdateRelationalDatabaseParametersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return Lightsail;
+}(LightsailClient));
+export { Lightsail };