@aws-sdk/client-lightsail 3.180.0 → 3.183.0

package/dist-es/Lightsail.js

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