@aws-sdk/client-iot 3.186.0 → 3.190.0

package/dist-es/IoT.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { AcceptCertificateTransferCommand, } from "./commands/AcceptCertificateTransferCommand";
 import { AddThingToBillingGroupCommand, } from "./commands/AddThingToBillingGroupCommand";
 import { AddThingToThingGroupCommand, } from "./commands/AddThingToThingGroupCommand";
@@ -237,3329 +236,3323 @@ import { UpdateThingGroupsForThingCommand, } from "./commands/UpdateThingGroupsF
 import { UpdateTopicRuleDestinationCommand, } from "./commands/UpdateTopicRuleDestinationCommand";
 import { ValidateSecurityProfileBehaviorsCommand, } from "./commands/ValidateSecurityProfileBehaviorsCommand";
 import { IoTClient } from "./IoTClient";
-var IoT = (function (_super) {
-    __extends(IoT, _super);
-    function IoT() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    IoT.prototype.acceptCertificateTransfer = function (args, optionsOrCb, cb) {
-        var command = new AcceptCertificateTransferCommand(args);
+export class IoT extends IoTClient {
+    acceptCertificateTransfer(args, optionsOrCb, cb) {
+        const command = new AcceptCertificateTransferCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.addThingToBillingGroup = function (args, optionsOrCb, cb) {
-        var command = new AddThingToBillingGroupCommand(args);
+    }
+    addThingToBillingGroup(args, optionsOrCb, cb) {
+        const command = new AddThingToBillingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.addThingToThingGroup = function (args, optionsOrCb, cb) {
-        var command = new AddThingToThingGroupCommand(args);
+    }
+    addThingToThingGroup(args, optionsOrCb, cb) {
+        const command = new AddThingToThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.associateTargetsWithJob = function (args, optionsOrCb, cb) {
-        var command = new AssociateTargetsWithJobCommand(args);
+    }
+    associateTargetsWithJob(args, optionsOrCb, cb) {
+        const command = new AssociateTargetsWithJobCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.attachPolicy = function (args, optionsOrCb, cb) {
-        var command = new AttachPolicyCommand(args);
+    }
+    attachPolicy(args, optionsOrCb, cb) {
+        const command = new AttachPolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.attachPrincipalPolicy = function (args, optionsOrCb, cb) {
-        var command = new AttachPrincipalPolicyCommand(args);
+    }
+    attachPrincipalPolicy(args, optionsOrCb, cb) {
+        const command = new AttachPrincipalPolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.attachSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new AttachSecurityProfileCommand(args);
+    }
+    attachSecurityProfile(args, optionsOrCb, cb) {
+        const command = new AttachSecurityProfileCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.attachThingPrincipal = function (args, optionsOrCb, cb) {
-        var command = new AttachThingPrincipalCommand(args);
+    }
+    attachThingPrincipal(args, optionsOrCb, cb) {
+        const command = new AttachThingPrincipalCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.cancelAuditMitigationActionsTask = function (args, optionsOrCb, cb) {
-        var command = new CancelAuditMitigationActionsTaskCommand(args);
+    }
+    cancelAuditMitigationActionsTask(args, optionsOrCb, cb) {
+        const command = new CancelAuditMitigationActionsTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.cancelAuditTask = function (args, optionsOrCb, cb) {
-        var command = new CancelAuditTaskCommand(args);
+    }
+    cancelAuditTask(args, optionsOrCb, cb) {
+        const command = new CancelAuditTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.cancelCertificateTransfer = function (args, optionsOrCb, cb) {
-        var command = new CancelCertificateTransferCommand(args);
+    }
+    cancelCertificateTransfer(args, optionsOrCb, cb) {
+        const command = new CancelCertificateTransferCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.cancelDetectMitigationActionsTask = function (args, optionsOrCb, cb) {
-        var command = new CancelDetectMitigationActionsTaskCommand(args);
+    }
+    cancelDetectMitigationActionsTask(args, optionsOrCb, cb) {
+        const command = new CancelDetectMitigationActionsTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.cancelJob = function (args, optionsOrCb, cb) {
-        var command = new CancelJobCommand(args);
+    }
+    cancelJob(args, optionsOrCb, cb) {
+        const command = new CancelJobCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.cancelJobExecution = function (args, optionsOrCb, cb) {
-        var command = new CancelJobExecutionCommand(args);
+    }
+    cancelJobExecution(args, optionsOrCb, cb) {
+        const command = new CancelJobExecutionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.clearDefaultAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new ClearDefaultAuthorizerCommand(args);
+    }
+    clearDefaultAuthorizer(args, optionsOrCb, cb) {
+        const command = new ClearDefaultAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.confirmTopicRuleDestination = function (args, optionsOrCb, cb) {
-        var command = new ConfirmTopicRuleDestinationCommand(args);
+    }
+    confirmTopicRuleDestination(args, optionsOrCb, cb) {
+        const command = new ConfirmTopicRuleDestinationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createAuditSuppression = function (args, optionsOrCb, cb) {
-        var command = new CreateAuditSuppressionCommand(args);
+    }
+    createAuditSuppression(args, optionsOrCb, cb) {
+        const command = new CreateAuditSuppressionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new CreateAuthorizerCommand(args);
+    }
+    createAuthorizer(args, optionsOrCb, cb) {
+        const command = new CreateAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createBillingGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateBillingGroupCommand(args);
+    }
+    createBillingGroup(args, optionsOrCb, cb) {
+        const command = new CreateBillingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createCertificateFromCsr = function (args, optionsOrCb, cb) {
-        var command = new CreateCertificateFromCsrCommand(args);
+    }
+    createCertificateFromCsr(args, optionsOrCb, cb) {
+        const command = new CreateCertificateFromCsrCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createCustomMetric = function (args, optionsOrCb, cb) {
-        var command = new CreateCustomMetricCommand(args);
+    }
+    createCustomMetric(args, optionsOrCb, cb) {
+        const command = new CreateCustomMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createDimension = function (args, optionsOrCb, cb) {
-        var command = new CreateDimensionCommand(args);
+    }
+    createDimension(args, optionsOrCb, cb) {
+        const command = new CreateDimensionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createDomainConfiguration = function (args, optionsOrCb, cb) {
-        var command = new CreateDomainConfigurationCommand(args);
+    }
+    createDomainConfiguration(args, optionsOrCb, cb) {
+        const command = new CreateDomainConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createDynamicThingGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateDynamicThingGroupCommand(args);
+    }
+    createDynamicThingGroup(args, optionsOrCb, cb) {
+        const command = new CreateDynamicThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createFleetMetric = function (args, optionsOrCb, cb) {
-        var command = new CreateFleetMetricCommand(args);
+    }
+    createFleetMetric(args, optionsOrCb, cb) {
+        const command = new CreateFleetMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createJob = function (args, optionsOrCb, cb) {
-        var command = new CreateJobCommand(args);
+    }
+    createJob(args, optionsOrCb, cb) {
+        const command = new CreateJobCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createJobTemplate = function (args, optionsOrCb, cb) {
-        var command = new CreateJobTemplateCommand(args);
+    }
+    createJobTemplate(args, optionsOrCb, cb) {
+        const command = new CreateJobTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createKeysAndCertificate = function (args, optionsOrCb, cb) {
-        var command = new CreateKeysAndCertificateCommand(args);
+    }
+    createKeysAndCertificate(args, optionsOrCb, cb) {
+        const command = new CreateKeysAndCertificateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createMitigationAction = function (args, optionsOrCb, cb) {
-        var command = new CreateMitigationActionCommand(args);
+    }
+    createMitigationAction(args, optionsOrCb, cb) {
+        const command = new CreateMitigationActionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createOTAUpdate = function (args, optionsOrCb, cb) {
-        var command = new CreateOTAUpdateCommand(args);
+    }
+    createOTAUpdate(args, optionsOrCb, cb) {
+        const command = new CreateOTAUpdateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createPolicy = function (args, optionsOrCb, cb) {
-        var command = new CreatePolicyCommand(args);
+    }
+    createPolicy(args, optionsOrCb, cb) {
+        const command = new CreatePolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createPolicyVersion = function (args, optionsOrCb, cb) {
-        var command = new CreatePolicyVersionCommand(args);
+    }
+    createPolicyVersion(args, optionsOrCb, cb) {
+        const command = new CreatePolicyVersionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createProvisioningClaim = function (args, optionsOrCb, cb) {
-        var command = new CreateProvisioningClaimCommand(args);
+    }
+    createProvisioningClaim(args, optionsOrCb, cb) {
+        const command = new CreateProvisioningClaimCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createProvisioningTemplate = function (args, optionsOrCb, cb) {
-        var command = new CreateProvisioningTemplateCommand(args);
+    }
+    createProvisioningTemplate(args, optionsOrCb, cb) {
+        const command = new CreateProvisioningTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createProvisioningTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new CreateProvisioningTemplateVersionCommand(args);
+    }
+    createProvisioningTemplateVersion(args, optionsOrCb, cb) {
+        const command = new CreateProvisioningTemplateVersionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createRoleAlias = function (args, optionsOrCb, cb) {
-        var command = new CreateRoleAliasCommand(args);
+    }
+    createRoleAlias(args, optionsOrCb, cb) {
+        const command = new CreateRoleAliasCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createScheduledAudit = function (args, optionsOrCb, cb) {
-        var command = new CreateScheduledAuditCommand(args);
+    }
+    createScheduledAudit(args, optionsOrCb, cb) {
+        const command = new CreateScheduledAuditCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new CreateSecurityProfileCommand(args);
+    }
+    createSecurityProfile(args, optionsOrCb, cb) {
+        const command = new CreateSecurityProfileCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createStream = function (args, optionsOrCb, cb) {
-        var command = new CreateStreamCommand(args);
+    }
+    createStream(args, optionsOrCb, cb) {
+        const command = new CreateStreamCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createThing = function (args, optionsOrCb, cb) {
-        var command = new CreateThingCommand(args);
+    }
+    createThing(args, optionsOrCb, cb) {
+        const command = new CreateThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createThingGroup = function (args, optionsOrCb, cb) {
-        var command = new CreateThingGroupCommand(args);
+    }
+    createThingGroup(args, optionsOrCb, cb) {
+        const command = new CreateThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createThingType = function (args, optionsOrCb, cb) {
-        var command = new CreateThingTypeCommand(args);
+    }
+    createThingType(args, optionsOrCb, cb) {
+        const command = new CreateThingTypeCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createTopicRule = function (args, optionsOrCb, cb) {
-        var command = new CreateTopicRuleCommand(args);
+    }
+    createTopicRule(args, optionsOrCb, cb) {
+        const command = new CreateTopicRuleCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.createTopicRuleDestination = function (args, optionsOrCb, cb) {
-        var command = new CreateTopicRuleDestinationCommand(args);
+    }
+    createTopicRuleDestination(args, optionsOrCb, cb) {
+        const command = new CreateTopicRuleDestinationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteAccountAuditConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteAccountAuditConfigurationCommand(args);
+    }
+    deleteAccountAuditConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteAccountAuditConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteAuditSuppression = function (args, optionsOrCb, cb) {
-        var command = new DeleteAuditSuppressionCommand(args);
+    }
+    deleteAuditSuppression(args, optionsOrCb, cb) {
+        const command = new DeleteAuditSuppressionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new DeleteAuthorizerCommand(args);
+    }
+    deleteAuthorizer(args, optionsOrCb, cb) {
+        const command = new DeleteAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteBillingGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteBillingGroupCommand(args);
+    }
+    deleteBillingGroup(args, optionsOrCb, cb) {
+        const command = new DeleteBillingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteCACertificate = function (args, optionsOrCb, cb) {
-        var command = new DeleteCACertificateCommand(args);
+    }
+    deleteCACertificate(args, optionsOrCb, cb) {
+        const command = new DeleteCACertificateCommand(args);
         if (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);
         }
-    };
-    IoT.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);
         }
-    };
-    IoT.prototype.deleteCustomMetric = function (args, optionsOrCb, cb) {
-        var command = new DeleteCustomMetricCommand(args);
+    }
+    deleteCustomMetric(args, optionsOrCb, cb) {
+        const command = new DeleteCustomMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteDimension = function (args, optionsOrCb, cb) {
-        var command = new DeleteDimensionCommand(args);
+    }
+    deleteDimension(args, optionsOrCb, cb) {
+        const command = new DeleteDimensionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteDomainConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DeleteDomainConfigurationCommand(args);
+    }
+    deleteDomainConfiguration(args, optionsOrCb, cb) {
+        const command = new DeleteDomainConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteDynamicThingGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteDynamicThingGroupCommand(args);
+    }
+    deleteDynamicThingGroup(args, optionsOrCb, cb) {
+        const command = new DeleteDynamicThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteFleetMetric = function (args, optionsOrCb, cb) {
-        var command = new DeleteFleetMetricCommand(args);
+    }
+    deleteFleetMetric(args, optionsOrCb, cb) {
+        const command = new DeleteFleetMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteJob = function (args, optionsOrCb, cb) {
-        var command = new DeleteJobCommand(args);
+    }
+    deleteJob(args, optionsOrCb, cb) {
+        const command = new DeleteJobCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteJobExecution = function (args, optionsOrCb, cb) {
-        var command = new DeleteJobExecutionCommand(args);
+    }
+    deleteJobExecution(args, optionsOrCb, cb) {
+        const command = new DeleteJobExecutionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteJobTemplate = function (args, optionsOrCb, cb) {
-        var command = new DeleteJobTemplateCommand(args);
+    }
+    deleteJobTemplate(args, optionsOrCb, cb) {
+        const command = new DeleteJobTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteMitigationAction = function (args, optionsOrCb, cb) {
-        var command = new DeleteMitigationActionCommand(args);
+    }
+    deleteMitigationAction(args, optionsOrCb, cb) {
+        const command = new DeleteMitigationActionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteOTAUpdate = function (args, optionsOrCb, cb) {
-        var command = new DeleteOTAUpdateCommand(args);
+    }
+    deleteOTAUpdate(args, optionsOrCb, cb) {
+        const command = new DeleteOTAUpdateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deletePolicy = function (args, optionsOrCb, cb) {
-        var command = new DeletePolicyCommand(args);
+    }
+    deletePolicy(args, optionsOrCb, cb) {
+        const command = new DeletePolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deletePolicyVersion = function (args, optionsOrCb, cb) {
-        var command = new DeletePolicyVersionCommand(args);
+    }
+    deletePolicyVersion(args, optionsOrCb, cb) {
+        const command = new DeletePolicyVersionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteProvisioningTemplate = function (args, optionsOrCb, cb) {
-        var command = new DeleteProvisioningTemplateCommand(args);
+    }
+    deleteProvisioningTemplate(args, optionsOrCb, cb) {
+        const command = new DeleteProvisioningTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteProvisioningTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new DeleteProvisioningTemplateVersionCommand(args);
+    }
+    deleteProvisioningTemplateVersion(args, optionsOrCb, cb) {
+        const command = new DeleteProvisioningTemplateVersionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteRegistrationCode = function (args, optionsOrCb, cb) {
-        var command = new DeleteRegistrationCodeCommand(args);
+    }
+    deleteRegistrationCode(args, optionsOrCb, cb) {
+        const command = new DeleteRegistrationCodeCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteRoleAlias = function (args, optionsOrCb, cb) {
-        var command = new DeleteRoleAliasCommand(args);
+    }
+    deleteRoleAlias(args, optionsOrCb, cb) {
+        const command = new DeleteRoleAliasCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteScheduledAudit = function (args, optionsOrCb, cb) {
-        var command = new DeleteScheduledAuditCommand(args);
+    }
+    deleteScheduledAudit(args, optionsOrCb, cb) {
+        const command = new DeleteScheduledAuditCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new DeleteSecurityProfileCommand(args);
+    }
+    deleteSecurityProfile(args, optionsOrCb, cb) {
+        const command = new DeleteSecurityProfileCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteStream = function (args, optionsOrCb, cb) {
-        var command = new DeleteStreamCommand(args);
+    }
+    deleteStream(args, optionsOrCb, cb) {
+        const command = new DeleteStreamCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteThing = function (args, optionsOrCb, cb) {
-        var command = new DeleteThingCommand(args);
+    }
+    deleteThing(args, optionsOrCb, cb) {
+        const command = new DeleteThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteThingGroup = function (args, optionsOrCb, cb) {
-        var command = new DeleteThingGroupCommand(args);
+    }
+    deleteThingGroup(args, optionsOrCb, cb) {
+        const command = new DeleteThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteThingType = function (args, optionsOrCb, cb) {
-        var command = new DeleteThingTypeCommand(args);
+    }
+    deleteThingType(args, optionsOrCb, cb) {
+        const command = new DeleteThingTypeCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteTopicRule = function (args, optionsOrCb, cb) {
-        var command = new DeleteTopicRuleCommand(args);
+    }
+    deleteTopicRule(args, optionsOrCb, cb) {
+        const command = new DeleteTopicRuleCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteTopicRuleDestination = function (args, optionsOrCb, cb) {
-        var command = new DeleteTopicRuleDestinationCommand(args);
+    }
+    deleteTopicRuleDestination(args, optionsOrCb, cb) {
+        const command = new DeleteTopicRuleDestinationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deleteV2LoggingLevel = function (args, optionsOrCb, cb) {
-        var command = new DeleteV2LoggingLevelCommand(args);
+    }
+    deleteV2LoggingLevel(args, optionsOrCb, cb) {
+        const command = new DeleteV2LoggingLevelCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.deprecateThingType = function (args, optionsOrCb, cb) {
-        var command = new DeprecateThingTypeCommand(args);
+    }
+    deprecateThingType(args, optionsOrCb, cb) {
+        const command = new DeprecateThingTypeCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeAccountAuditConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DescribeAccountAuditConfigurationCommand(args);
+    }
+    describeAccountAuditConfiguration(args, optionsOrCb, cb) {
+        const command = new DescribeAccountAuditConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeAuditFinding = function (args, optionsOrCb, cb) {
-        var command = new DescribeAuditFindingCommand(args);
+    }
+    describeAuditFinding(args, optionsOrCb, cb) {
+        const command = new DescribeAuditFindingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeAuditMitigationActionsTask = function (args, optionsOrCb, cb) {
-        var command = new DescribeAuditMitigationActionsTaskCommand(args);
+    }
+    describeAuditMitigationActionsTask(args, optionsOrCb, cb) {
+        const command = new DescribeAuditMitigationActionsTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeAuditSuppression = function (args, optionsOrCb, cb) {
-        var command = new DescribeAuditSuppressionCommand(args);
+    }
+    describeAuditSuppression(args, optionsOrCb, cb) {
+        const command = new DescribeAuditSuppressionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeAuditTask = function (args, optionsOrCb, cb) {
-        var command = new DescribeAuditTaskCommand(args);
+    }
+    describeAuditTask(args, optionsOrCb, cb) {
+        const command = new DescribeAuditTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new DescribeAuthorizerCommand(args);
+    }
+    describeAuthorizer(args, optionsOrCb, cb) {
+        const command = new DescribeAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeBillingGroup = function (args, optionsOrCb, cb) {
-        var command = new DescribeBillingGroupCommand(args);
+    }
+    describeBillingGroup(args, optionsOrCb, cb) {
+        const command = new DescribeBillingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeCACertificate = function (args, optionsOrCb, cb) {
-        var command = new DescribeCACertificateCommand(args);
+    }
+    describeCACertificate(args, optionsOrCb, cb) {
+        const command = new DescribeCACertificateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeCertificate = function (args, optionsOrCb, cb) {
-        var command = new DescribeCertificateCommand(args);
+    }
+    describeCertificate(args, optionsOrCb, cb) {
+        const command = new DescribeCertificateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeCustomMetric = function (args, optionsOrCb, cb) {
-        var command = new DescribeCustomMetricCommand(args);
+    }
+    describeCustomMetric(args, optionsOrCb, cb) {
+        const command = new DescribeCustomMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeDefaultAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new DescribeDefaultAuthorizerCommand(args);
+    }
+    describeDefaultAuthorizer(args, optionsOrCb, cb) {
+        const command = new DescribeDefaultAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeDetectMitigationActionsTask = function (args, optionsOrCb, cb) {
-        var command = new DescribeDetectMitigationActionsTaskCommand(args);
+    }
+    describeDetectMitigationActionsTask(args, optionsOrCb, cb) {
+        const command = new DescribeDetectMitigationActionsTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeDimension = function (args, optionsOrCb, cb) {
-        var command = new DescribeDimensionCommand(args);
+    }
+    describeDimension(args, optionsOrCb, cb) {
+        const command = new DescribeDimensionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeDomainConfiguration = function (args, optionsOrCb, cb) {
-        var command = new DescribeDomainConfigurationCommand(args);
+    }
+    describeDomainConfiguration(args, optionsOrCb, cb) {
+        const command = new DescribeDomainConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeEndpoint = function (args, optionsOrCb, cb) {
-        var command = new DescribeEndpointCommand(args);
+    }
+    describeEndpoint(args, optionsOrCb, cb) {
+        const command = new DescribeEndpointCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeEventConfigurations = function (args, optionsOrCb, cb) {
-        var command = new DescribeEventConfigurationsCommand(args);
+    }
+    describeEventConfigurations(args, optionsOrCb, cb) {
+        const command = new DescribeEventConfigurationsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeFleetMetric = function (args, optionsOrCb, cb) {
-        var command = new DescribeFleetMetricCommand(args);
+    }
+    describeFleetMetric(args, optionsOrCb, cb) {
+        const command = new DescribeFleetMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeIndex = function (args, optionsOrCb, cb) {
-        var command = new DescribeIndexCommand(args);
+    }
+    describeIndex(args, optionsOrCb, cb) {
+        const command = new DescribeIndexCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeJob = function (args, optionsOrCb, cb) {
-        var command = new DescribeJobCommand(args);
+    }
+    describeJob(args, optionsOrCb, cb) {
+        const command = new DescribeJobCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeJobExecution = function (args, optionsOrCb, cb) {
-        var command = new DescribeJobExecutionCommand(args);
+    }
+    describeJobExecution(args, optionsOrCb, cb) {
+        const command = new DescribeJobExecutionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeJobTemplate = function (args, optionsOrCb, cb) {
-        var command = new DescribeJobTemplateCommand(args);
+    }
+    describeJobTemplate(args, optionsOrCb, cb) {
+        const command = new DescribeJobTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeManagedJobTemplate = function (args, optionsOrCb, cb) {
-        var command = new DescribeManagedJobTemplateCommand(args);
+    }
+    describeManagedJobTemplate(args, optionsOrCb, cb) {
+        const command = new DescribeManagedJobTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeMitigationAction = function (args, optionsOrCb, cb) {
-        var command = new DescribeMitigationActionCommand(args);
+    }
+    describeMitigationAction(args, optionsOrCb, cb) {
+        const command = new DescribeMitigationActionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeProvisioningTemplate = function (args, optionsOrCb, cb) {
-        var command = new DescribeProvisioningTemplateCommand(args);
+    }
+    describeProvisioningTemplate(args, optionsOrCb, cb) {
+        const command = new DescribeProvisioningTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeProvisioningTemplateVersion = function (args, optionsOrCb, cb) {
-        var command = new DescribeProvisioningTemplateVersionCommand(args);
+    }
+    describeProvisioningTemplateVersion(args, optionsOrCb, cb) {
+        const command = new DescribeProvisioningTemplateVersionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeRoleAlias = function (args, optionsOrCb, cb) {
-        var command = new DescribeRoleAliasCommand(args);
+    }
+    describeRoleAlias(args, optionsOrCb, cb) {
+        const command = new DescribeRoleAliasCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeScheduledAudit = function (args, optionsOrCb, cb) {
-        var command = new DescribeScheduledAuditCommand(args);
+    }
+    describeScheduledAudit(args, optionsOrCb, cb) {
+        const command = new DescribeScheduledAuditCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new DescribeSecurityProfileCommand(args);
+    }
+    describeSecurityProfile(args, optionsOrCb, cb) {
+        const command = new DescribeSecurityProfileCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeStream = function (args, optionsOrCb, cb) {
-        var command = new DescribeStreamCommand(args);
+    }
+    describeStream(args, optionsOrCb, cb) {
+        const command = new DescribeStreamCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeThing = function (args, optionsOrCb, cb) {
-        var command = new DescribeThingCommand(args);
+    }
+    describeThing(args, optionsOrCb, cb) {
+        const command = new DescribeThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeThingGroup = function (args, optionsOrCb, cb) {
-        var command = new DescribeThingGroupCommand(args);
+    }
+    describeThingGroup(args, optionsOrCb, cb) {
+        const command = new DescribeThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeThingRegistrationTask = function (args, optionsOrCb, cb) {
-        var command = new DescribeThingRegistrationTaskCommand(args);
+    }
+    describeThingRegistrationTask(args, optionsOrCb, cb) {
+        const command = new DescribeThingRegistrationTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.describeThingType = function (args, optionsOrCb, cb) {
-        var command = new DescribeThingTypeCommand(args);
+    }
+    describeThingType(args, optionsOrCb, cb) {
+        const command = new DescribeThingTypeCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.detachPolicy = function (args, optionsOrCb, cb) {
-        var command = new DetachPolicyCommand(args);
+    }
+    detachPolicy(args, optionsOrCb, cb) {
+        const command = new DetachPolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.detachPrincipalPolicy = function (args, optionsOrCb, cb) {
-        var command = new DetachPrincipalPolicyCommand(args);
+    }
+    detachPrincipalPolicy(args, optionsOrCb, cb) {
+        const command = new DetachPrincipalPolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.detachSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new DetachSecurityProfileCommand(args);
+    }
+    detachSecurityProfile(args, optionsOrCb, cb) {
+        const command = new DetachSecurityProfileCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.detachThingPrincipal = function (args, optionsOrCb, cb) {
-        var command = new DetachThingPrincipalCommand(args);
+    }
+    detachThingPrincipal(args, optionsOrCb, cb) {
+        const command = new DetachThingPrincipalCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.disableTopicRule = function (args, optionsOrCb, cb) {
-        var command = new DisableTopicRuleCommand(args);
+    }
+    disableTopicRule(args, optionsOrCb, cb) {
+        const command = new DisableTopicRuleCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.enableTopicRule = function (args, optionsOrCb, cb) {
-        var command = new EnableTopicRuleCommand(args);
+    }
+    enableTopicRule(args, optionsOrCb, cb) {
+        const command = new EnableTopicRuleCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getBehaviorModelTrainingSummaries = function (args, optionsOrCb, cb) {
-        var command = new GetBehaviorModelTrainingSummariesCommand(args);
+    }
+    getBehaviorModelTrainingSummaries(args, optionsOrCb, cb) {
+        const command = new GetBehaviorModelTrainingSummariesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getBucketsAggregation = function (args, optionsOrCb, cb) {
-        var command = new GetBucketsAggregationCommand(args);
+    }
+    getBucketsAggregation(args, optionsOrCb, cb) {
+        const command = new GetBucketsAggregationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getCardinality = function (args, optionsOrCb, cb) {
-        var command = new GetCardinalityCommand(args);
+    }
+    getCardinality(args, optionsOrCb, cb) {
+        const command = new GetCardinalityCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getEffectivePolicies = function (args, optionsOrCb, cb) {
-        var command = new GetEffectivePoliciesCommand(args);
+    }
+    getEffectivePolicies(args, optionsOrCb, cb) {
+        const command = new GetEffectivePoliciesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getIndexingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new GetIndexingConfigurationCommand(args);
+    }
+    getIndexingConfiguration(args, optionsOrCb, cb) {
+        const command = new GetIndexingConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getJobDocument = function (args, optionsOrCb, cb) {
-        var command = new GetJobDocumentCommand(args);
+    }
+    getJobDocument(args, optionsOrCb, cb) {
+        const command = new GetJobDocumentCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getLoggingOptions = function (args, optionsOrCb, cb) {
-        var command = new GetLoggingOptionsCommand(args);
+    }
+    getLoggingOptions(args, optionsOrCb, cb) {
+        const command = new GetLoggingOptionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getOTAUpdate = function (args, optionsOrCb, cb) {
-        var command = new GetOTAUpdateCommand(args);
+    }
+    getOTAUpdate(args, optionsOrCb, cb) {
+        const command = new GetOTAUpdateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getPercentiles = function (args, optionsOrCb, cb) {
-        var command = new GetPercentilesCommand(args);
+    }
+    getPercentiles(args, optionsOrCb, cb) {
+        const command = new GetPercentilesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getPolicy = function (args, optionsOrCb, cb) {
-        var command = new GetPolicyCommand(args);
+    }
+    getPolicy(args, optionsOrCb, cb) {
+        const command = new GetPolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getPolicyVersion = function (args, optionsOrCb, cb) {
-        var command = new GetPolicyVersionCommand(args);
+    }
+    getPolicyVersion(args, optionsOrCb, cb) {
+        const command = new GetPolicyVersionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getRegistrationCode = function (args, optionsOrCb, cb) {
-        var command = new GetRegistrationCodeCommand(args);
+    }
+    getRegistrationCode(args, optionsOrCb, cb) {
+        const command = new GetRegistrationCodeCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getStatistics = function (args, optionsOrCb, cb) {
-        var command = new GetStatisticsCommand(args);
+    }
+    getStatistics(args, optionsOrCb, cb) {
+        const command = new GetStatisticsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getTopicRule = function (args, optionsOrCb, cb) {
-        var command = new GetTopicRuleCommand(args);
+    }
+    getTopicRule(args, optionsOrCb, cb) {
+        const command = new GetTopicRuleCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getTopicRuleDestination = function (args, optionsOrCb, cb) {
-        var command = new GetTopicRuleDestinationCommand(args);
+    }
+    getTopicRuleDestination(args, optionsOrCb, cb) {
+        const command = new GetTopicRuleDestinationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.getV2LoggingOptions = function (args, optionsOrCb, cb) {
-        var command = new GetV2LoggingOptionsCommand(args);
+    }
+    getV2LoggingOptions(args, optionsOrCb, cb) {
+        const command = new GetV2LoggingOptionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listActiveViolations = function (args, optionsOrCb, cb) {
-        var command = new ListActiveViolationsCommand(args);
+    }
+    listActiveViolations(args, optionsOrCb, cb) {
+        const command = new ListActiveViolationsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listAttachedPolicies = function (args, optionsOrCb, cb) {
-        var command = new ListAttachedPoliciesCommand(args);
+    }
+    listAttachedPolicies(args, optionsOrCb, cb) {
+        const command = new ListAttachedPoliciesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listAuditFindings = function (args, optionsOrCb, cb) {
-        var command = new ListAuditFindingsCommand(args);
+    }
+    listAuditFindings(args, optionsOrCb, cb) {
+        const command = new ListAuditFindingsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listAuditMitigationActionsExecutions = function (args, optionsOrCb, cb) {
-        var command = new ListAuditMitigationActionsExecutionsCommand(args);
+    }
+    listAuditMitigationActionsExecutions(args, optionsOrCb, cb) {
+        const command = new ListAuditMitigationActionsExecutionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listAuditMitigationActionsTasks = function (args, optionsOrCb, cb) {
-        var command = new ListAuditMitigationActionsTasksCommand(args);
+    }
+    listAuditMitigationActionsTasks(args, optionsOrCb, cb) {
+        const command = new ListAuditMitigationActionsTasksCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listAuditSuppressions = function (args, optionsOrCb, cb) {
-        var command = new ListAuditSuppressionsCommand(args);
+    }
+    listAuditSuppressions(args, optionsOrCb, cb) {
+        const command = new ListAuditSuppressionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listAuditTasks = function (args, optionsOrCb, cb) {
-        var command = new ListAuditTasksCommand(args);
+    }
+    listAuditTasks(args, optionsOrCb, cb) {
+        const command = new ListAuditTasksCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listAuthorizers = function (args, optionsOrCb, cb) {
-        var command = new ListAuthorizersCommand(args);
+    }
+    listAuthorizers(args, optionsOrCb, cb) {
+        const command = new ListAuthorizersCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listBillingGroups = function (args, optionsOrCb, cb) {
-        var command = new ListBillingGroupsCommand(args);
+    }
+    listBillingGroups(args, optionsOrCb, cb) {
+        const command = new ListBillingGroupsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listCACertificates = function (args, optionsOrCb, cb) {
-        var command = new ListCACertificatesCommand(args);
+    }
+    listCACertificates(args, optionsOrCb, cb) {
+        const command = new ListCACertificatesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listCertificates = function (args, optionsOrCb, cb) {
-        var command = new ListCertificatesCommand(args);
+    }
+    listCertificates(args, optionsOrCb, cb) {
+        const command = new ListCertificatesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listCertificatesByCA = function (args, optionsOrCb, cb) {
-        var command = new ListCertificatesByCACommand(args);
+    }
+    listCertificatesByCA(args, optionsOrCb, cb) {
+        const command = new ListCertificatesByCACommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listCustomMetrics = function (args, optionsOrCb, cb) {
-        var command = new ListCustomMetricsCommand(args);
+    }
+    listCustomMetrics(args, optionsOrCb, cb) {
+        const command = new ListCustomMetricsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listDetectMitigationActionsExecutions = function (args, optionsOrCb, cb) {
-        var command = new ListDetectMitigationActionsExecutionsCommand(args);
+    }
+    listDetectMitigationActionsExecutions(args, optionsOrCb, cb) {
+        const command = new ListDetectMitigationActionsExecutionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listDetectMitigationActionsTasks = function (args, optionsOrCb, cb) {
-        var command = new ListDetectMitigationActionsTasksCommand(args);
+    }
+    listDetectMitigationActionsTasks(args, optionsOrCb, cb) {
+        const command = new ListDetectMitigationActionsTasksCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listDimensions = function (args, optionsOrCb, cb) {
-        var command = new ListDimensionsCommand(args);
+    }
+    listDimensions(args, optionsOrCb, cb) {
+        const command = new ListDimensionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listDomainConfigurations = function (args, optionsOrCb, cb) {
-        var command = new ListDomainConfigurationsCommand(args);
+    }
+    listDomainConfigurations(args, optionsOrCb, cb) {
+        const command = new ListDomainConfigurationsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listFleetMetrics = function (args, optionsOrCb, cb) {
-        var command = new ListFleetMetricsCommand(args);
+    }
+    listFleetMetrics(args, optionsOrCb, cb) {
+        const command = new ListFleetMetricsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listIndices = function (args, optionsOrCb, cb) {
-        var command = new ListIndicesCommand(args);
+    }
+    listIndices(args, optionsOrCb, cb) {
+        const command = new ListIndicesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listJobExecutionsForJob = function (args, optionsOrCb, cb) {
-        var command = new ListJobExecutionsForJobCommand(args);
+    }
+    listJobExecutionsForJob(args, optionsOrCb, cb) {
+        const command = new ListJobExecutionsForJobCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listJobExecutionsForThing = function (args, optionsOrCb, cb) {
-        var command = new ListJobExecutionsForThingCommand(args);
+    }
+    listJobExecutionsForThing(args, optionsOrCb, cb) {
+        const command = new ListJobExecutionsForThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listJobs = function (args, optionsOrCb, cb) {
-        var command = new ListJobsCommand(args);
+    }
+    listJobs(args, optionsOrCb, cb) {
+        const command = new ListJobsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listJobTemplates = function (args, optionsOrCb, cb) {
-        var command = new ListJobTemplatesCommand(args);
+    }
+    listJobTemplates(args, optionsOrCb, cb) {
+        const command = new ListJobTemplatesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listManagedJobTemplates = function (args, optionsOrCb, cb) {
-        var command = new ListManagedJobTemplatesCommand(args);
+    }
+    listManagedJobTemplates(args, optionsOrCb, cb) {
+        const command = new ListManagedJobTemplatesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listMetricValues = function (args, optionsOrCb, cb) {
-        var command = new ListMetricValuesCommand(args);
+    }
+    listMetricValues(args, optionsOrCb, cb) {
+        const command = new ListMetricValuesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listMitigationActions = function (args, optionsOrCb, cb) {
-        var command = new ListMitigationActionsCommand(args);
+    }
+    listMitigationActions(args, optionsOrCb, cb) {
+        const command = new ListMitigationActionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listOTAUpdates = function (args, optionsOrCb, cb) {
-        var command = new ListOTAUpdatesCommand(args);
+    }
+    listOTAUpdates(args, optionsOrCb, cb) {
+        const command = new ListOTAUpdatesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listOutgoingCertificates = function (args, optionsOrCb, cb) {
-        var command = new ListOutgoingCertificatesCommand(args);
+    }
+    listOutgoingCertificates(args, optionsOrCb, cb) {
+        const command = new ListOutgoingCertificatesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listPolicies = function (args, optionsOrCb, cb) {
-        var command = new ListPoliciesCommand(args);
+    }
+    listPolicies(args, optionsOrCb, cb) {
+        const command = new ListPoliciesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listPolicyPrincipals = function (args, optionsOrCb, cb) {
-        var command = new ListPolicyPrincipalsCommand(args);
+    }
+    listPolicyPrincipals(args, optionsOrCb, cb) {
+        const command = new ListPolicyPrincipalsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listPolicyVersions = function (args, optionsOrCb, cb) {
-        var command = new ListPolicyVersionsCommand(args);
+    }
+    listPolicyVersions(args, optionsOrCb, cb) {
+        const command = new ListPolicyVersionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listPrincipalPolicies = function (args, optionsOrCb, cb) {
-        var command = new ListPrincipalPoliciesCommand(args);
+    }
+    listPrincipalPolicies(args, optionsOrCb, cb) {
+        const command = new ListPrincipalPoliciesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listPrincipalThings = function (args, optionsOrCb, cb) {
-        var command = new ListPrincipalThingsCommand(args);
+    }
+    listPrincipalThings(args, optionsOrCb, cb) {
+        const command = new ListPrincipalThingsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listProvisioningTemplates = function (args, optionsOrCb, cb) {
-        var command = new ListProvisioningTemplatesCommand(args);
+    }
+    listProvisioningTemplates(args, optionsOrCb, cb) {
+        const command = new ListProvisioningTemplatesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listProvisioningTemplateVersions = function (args, optionsOrCb, cb) {
-        var command = new ListProvisioningTemplateVersionsCommand(args);
+    }
+    listProvisioningTemplateVersions(args, optionsOrCb, cb) {
+        const command = new ListProvisioningTemplateVersionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listRoleAliases = function (args, optionsOrCb, cb) {
-        var command = new ListRoleAliasesCommand(args);
+    }
+    listRoleAliases(args, optionsOrCb, cb) {
+        const command = new ListRoleAliasesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listScheduledAudits = function (args, optionsOrCb, cb) {
-        var command = new ListScheduledAuditsCommand(args);
+    }
+    listScheduledAudits(args, optionsOrCb, cb) {
+        const command = new ListScheduledAuditsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listSecurityProfiles = function (args, optionsOrCb, cb) {
-        var command = new ListSecurityProfilesCommand(args);
+    }
+    listSecurityProfiles(args, optionsOrCb, cb) {
+        const command = new ListSecurityProfilesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listSecurityProfilesForTarget = function (args, optionsOrCb, cb) {
-        var command = new ListSecurityProfilesForTargetCommand(args);
+    }
+    listSecurityProfilesForTarget(args, optionsOrCb, cb) {
+        const command = new ListSecurityProfilesForTargetCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listStreams = function (args, optionsOrCb, cb) {
-        var command = new ListStreamsCommand(args);
+    }
+    listStreams(args, optionsOrCb, cb) {
+        const command = new ListStreamsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listTargetsForPolicy = function (args, optionsOrCb, cb) {
-        var command = new ListTargetsForPolicyCommand(args);
+    }
+    listTargetsForPolicy(args, optionsOrCb, cb) {
+        const command = new ListTargetsForPolicyCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listTargetsForSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new ListTargetsForSecurityProfileCommand(args);
+    }
+    listTargetsForSecurityProfile(args, optionsOrCb, cb) {
+        const command = new ListTargetsForSecurityProfileCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingGroups = function (args, optionsOrCb, cb) {
-        var command = new ListThingGroupsCommand(args);
+    }
+    listThingGroups(args, optionsOrCb, cb) {
+        const command = new ListThingGroupsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingGroupsForThing = function (args, optionsOrCb, cb) {
-        var command = new ListThingGroupsForThingCommand(args);
+    }
+    listThingGroupsForThing(args, optionsOrCb, cb) {
+        const command = new ListThingGroupsForThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingPrincipals = function (args, optionsOrCb, cb) {
-        var command = new ListThingPrincipalsCommand(args);
+    }
+    listThingPrincipals(args, optionsOrCb, cb) {
+        const command = new ListThingPrincipalsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingRegistrationTaskReports = function (args, optionsOrCb, cb) {
-        var command = new ListThingRegistrationTaskReportsCommand(args);
+    }
+    listThingRegistrationTaskReports(args, optionsOrCb, cb) {
+        const command = new ListThingRegistrationTaskReportsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingRegistrationTasks = function (args, optionsOrCb, cb) {
-        var command = new ListThingRegistrationTasksCommand(args);
+    }
+    listThingRegistrationTasks(args, optionsOrCb, cb) {
+        const command = new ListThingRegistrationTasksCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThings = function (args, optionsOrCb, cb) {
-        var command = new ListThingsCommand(args);
+    }
+    listThings(args, optionsOrCb, cb) {
+        const command = new ListThingsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingsInBillingGroup = function (args, optionsOrCb, cb) {
-        var command = new ListThingsInBillingGroupCommand(args);
+    }
+    listThingsInBillingGroup(args, optionsOrCb, cb) {
+        const command = new ListThingsInBillingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingsInThingGroup = function (args, optionsOrCb, cb) {
-        var command = new ListThingsInThingGroupCommand(args);
+    }
+    listThingsInThingGroup(args, optionsOrCb, cb) {
+        const command = new ListThingsInThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listThingTypes = function (args, optionsOrCb, cb) {
-        var command = new ListThingTypesCommand(args);
+    }
+    listThingTypes(args, optionsOrCb, cb) {
+        const command = new ListThingTypesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listTopicRuleDestinations = function (args, optionsOrCb, cb) {
-        var command = new ListTopicRuleDestinationsCommand(args);
+    }
+    listTopicRuleDestinations(args, optionsOrCb, cb) {
+        const command = new ListTopicRuleDestinationsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listTopicRules = function (args, optionsOrCb, cb) {
-        var command = new ListTopicRulesCommand(args);
+    }
+    listTopicRules(args, optionsOrCb, cb) {
+        const command = new ListTopicRulesCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listV2LoggingLevels = function (args, optionsOrCb, cb) {
-        var command = new ListV2LoggingLevelsCommand(args);
+    }
+    listV2LoggingLevels(args, optionsOrCb, cb) {
+        const command = new ListV2LoggingLevelsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.listViolationEvents = function (args, optionsOrCb, cb) {
-        var command = new ListViolationEventsCommand(args);
+    }
+    listViolationEvents(args, optionsOrCb, cb) {
+        const command = new ListViolationEventsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.putVerificationStateOnViolation = function (args, optionsOrCb, cb) {
-        var command = new PutVerificationStateOnViolationCommand(args);
+    }
+    putVerificationStateOnViolation(args, optionsOrCb, cb) {
+        const command = new PutVerificationStateOnViolationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.registerCACertificate = function (args, optionsOrCb, cb) {
-        var command = new RegisterCACertificateCommand(args);
+    }
+    registerCACertificate(args, optionsOrCb, cb) {
+        const command = new RegisterCACertificateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.registerCertificate = function (args, optionsOrCb, cb) {
-        var command = new RegisterCertificateCommand(args);
+    }
+    registerCertificate(args, optionsOrCb, cb) {
+        const command = new RegisterCertificateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.registerCertificateWithoutCA = function (args, optionsOrCb, cb) {
-        var command = new RegisterCertificateWithoutCACommand(args);
+    }
+    registerCertificateWithoutCA(args, optionsOrCb, cb) {
+        const command = new RegisterCertificateWithoutCACommand(args);
         if (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);
         }
-    };
-    IoT.prototype.registerThing = function (args, optionsOrCb, cb) {
-        var command = new RegisterThingCommand(args);
+    }
+    registerThing(args, optionsOrCb, cb) {
+        const command = new RegisterThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.rejectCertificateTransfer = function (args, optionsOrCb, cb) {
-        var command = new RejectCertificateTransferCommand(args);
+    }
+    rejectCertificateTransfer(args, optionsOrCb, cb) {
+        const command = new RejectCertificateTransferCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.removeThingFromBillingGroup = function (args, optionsOrCb, cb) {
-        var command = new RemoveThingFromBillingGroupCommand(args);
+    }
+    removeThingFromBillingGroup(args, optionsOrCb, cb) {
+        const command = new RemoveThingFromBillingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.removeThingFromThingGroup = function (args, optionsOrCb, cb) {
-        var command = new RemoveThingFromThingGroupCommand(args);
+    }
+    removeThingFromThingGroup(args, optionsOrCb, cb) {
+        const command = new RemoveThingFromThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.replaceTopicRule = function (args, optionsOrCb, cb) {
-        var command = new ReplaceTopicRuleCommand(args);
+    }
+    replaceTopicRule(args, optionsOrCb, cb) {
+        const command = new ReplaceTopicRuleCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.searchIndex = function (args, optionsOrCb, cb) {
-        var command = new SearchIndexCommand(args);
+    }
+    searchIndex(args, optionsOrCb, cb) {
+        const command = new SearchIndexCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.setDefaultAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new SetDefaultAuthorizerCommand(args);
+    }
+    setDefaultAuthorizer(args, optionsOrCb, cb) {
+        const command = new SetDefaultAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.setDefaultPolicyVersion = function (args, optionsOrCb, cb) {
-        var command = new SetDefaultPolicyVersionCommand(args);
+    }
+    setDefaultPolicyVersion(args, optionsOrCb, cb) {
+        const command = new SetDefaultPolicyVersionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.setLoggingOptions = function (args, optionsOrCb, cb) {
-        var command = new SetLoggingOptionsCommand(args);
+    }
+    setLoggingOptions(args, optionsOrCb, cb) {
+        const command = new SetLoggingOptionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.setV2LoggingLevel = function (args, optionsOrCb, cb) {
-        var command = new SetV2LoggingLevelCommand(args);
+    }
+    setV2LoggingLevel(args, optionsOrCb, cb) {
+        const command = new SetV2LoggingLevelCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.setV2LoggingOptions = function (args, optionsOrCb, cb) {
-        var command = new SetV2LoggingOptionsCommand(args);
+    }
+    setV2LoggingOptions(args, optionsOrCb, cb) {
+        const command = new SetV2LoggingOptionsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.startAuditMitigationActionsTask = function (args, optionsOrCb, cb) {
-        var command = new StartAuditMitigationActionsTaskCommand(args);
+    }
+    startAuditMitigationActionsTask(args, optionsOrCb, cb) {
+        const command = new StartAuditMitigationActionsTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.startDetectMitigationActionsTask = function (args, optionsOrCb, cb) {
-        var command = new StartDetectMitigationActionsTaskCommand(args);
+    }
+    startDetectMitigationActionsTask(args, optionsOrCb, cb) {
+        const command = new StartDetectMitigationActionsTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.startOnDemandAuditTask = function (args, optionsOrCb, cb) {
-        var command = new StartOnDemandAuditTaskCommand(args);
+    }
+    startOnDemandAuditTask(args, optionsOrCb, cb) {
+        const command = new StartOnDemandAuditTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.startThingRegistrationTask = function (args, optionsOrCb, cb) {
-        var command = new StartThingRegistrationTaskCommand(args);
+    }
+    startThingRegistrationTask(args, optionsOrCb, cb) {
+        const command = new StartThingRegistrationTaskCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.stopThingRegistrationTask = function (args, optionsOrCb, cb) {
-        var command = new StopThingRegistrationTaskCommand(args);
+    }
+    stopThingRegistrationTask(args, optionsOrCb, cb) {
+        const command = new StopThingRegistrationTaskCommand(args);
         if (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);
         }
-    };
-    IoT.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);
         }
-    };
-    IoT.prototype.testAuthorization = function (args, optionsOrCb, cb) {
-        var command = new TestAuthorizationCommand(args);
+    }
+    testAuthorization(args, optionsOrCb, cb) {
+        const command = new TestAuthorizationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.testInvokeAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new TestInvokeAuthorizerCommand(args);
+    }
+    testInvokeAuthorizer(args, optionsOrCb, cb) {
+        const command = new TestInvokeAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.transferCertificate = function (args, optionsOrCb, cb) {
-        var command = new TransferCertificateCommand(args);
+    }
+    transferCertificate(args, optionsOrCb, cb) {
+        const command = new TransferCertificateCommand(args);
         if (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);
         }
-    };
-    IoT.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);
         }
-    };
-    IoT.prototype.updateAccountAuditConfiguration = function (args, optionsOrCb, cb) {
-        var command = new UpdateAccountAuditConfigurationCommand(args);
+    }
+    updateAccountAuditConfiguration(args, optionsOrCb, cb) {
+        const command = new UpdateAccountAuditConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateAuditSuppression = function (args, optionsOrCb, cb) {
-        var command = new UpdateAuditSuppressionCommand(args);
+    }
+    updateAuditSuppression(args, optionsOrCb, cb) {
+        const command = new UpdateAuditSuppressionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateAuthorizer = function (args, optionsOrCb, cb) {
-        var command = new UpdateAuthorizerCommand(args);
+    }
+    updateAuthorizer(args, optionsOrCb, cb) {
+        const command = new UpdateAuthorizerCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateBillingGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateBillingGroupCommand(args);
+    }
+    updateBillingGroup(args, optionsOrCb, cb) {
+        const command = new UpdateBillingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateCACertificate = function (args, optionsOrCb, cb) {
-        var command = new UpdateCACertificateCommand(args);
+    }
+    updateCACertificate(args, optionsOrCb, cb) {
+        const command = new UpdateCACertificateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateCertificate = function (args, optionsOrCb, cb) {
-        var command = new UpdateCertificateCommand(args);
+    }
+    updateCertificate(args, optionsOrCb, cb) {
+        const command = new UpdateCertificateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateCustomMetric = function (args, optionsOrCb, cb) {
-        var command = new UpdateCustomMetricCommand(args);
+    }
+    updateCustomMetric(args, optionsOrCb, cb) {
+        const command = new UpdateCustomMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateDimension = function (args, optionsOrCb, cb) {
-        var command = new UpdateDimensionCommand(args);
+    }
+    updateDimension(args, optionsOrCb, cb) {
+        const command = new UpdateDimensionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateDomainConfiguration = function (args, optionsOrCb, cb) {
-        var command = new UpdateDomainConfigurationCommand(args);
+    }
+    updateDomainConfiguration(args, optionsOrCb, cb) {
+        const command = new UpdateDomainConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateDynamicThingGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateDynamicThingGroupCommand(args);
+    }
+    updateDynamicThingGroup(args, optionsOrCb, cb) {
+        const command = new UpdateDynamicThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateEventConfigurations = function (args, optionsOrCb, cb) {
-        var command = new UpdateEventConfigurationsCommand(args);
+    }
+    updateEventConfigurations(args, optionsOrCb, cb) {
+        const command = new UpdateEventConfigurationsCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateFleetMetric = function (args, optionsOrCb, cb) {
-        var command = new UpdateFleetMetricCommand(args);
+    }
+    updateFleetMetric(args, optionsOrCb, cb) {
+        const command = new UpdateFleetMetricCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateIndexingConfiguration = function (args, optionsOrCb, cb) {
-        var command = new UpdateIndexingConfigurationCommand(args);
+    }
+    updateIndexingConfiguration(args, optionsOrCb, cb) {
+        const command = new UpdateIndexingConfigurationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateJob = function (args, optionsOrCb, cb) {
-        var command = new UpdateJobCommand(args);
+    }
+    updateJob(args, optionsOrCb, cb) {
+        const command = new UpdateJobCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateMitigationAction = function (args, optionsOrCb, cb) {
-        var command = new UpdateMitigationActionCommand(args);
+    }
+    updateMitigationAction(args, optionsOrCb, cb) {
+        const command = new UpdateMitigationActionCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateProvisioningTemplate = function (args, optionsOrCb, cb) {
-        var command = new UpdateProvisioningTemplateCommand(args);
+    }
+    updateProvisioningTemplate(args, optionsOrCb, cb) {
+        const command = new UpdateProvisioningTemplateCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateRoleAlias = function (args, optionsOrCb, cb) {
-        var command = new UpdateRoleAliasCommand(args);
+    }
+    updateRoleAlias(args, optionsOrCb, cb) {
+        const command = new UpdateRoleAliasCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateScheduledAudit = function (args, optionsOrCb, cb) {
-        var command = new UpdateScheduledAuditCommand(args);
+    }
+    updateScheduledAudit(args, optionsOrCb, cb) {
+        const command = new UpdateScheduledAuditCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateSecurityProfile = function (args, optionsOrCb, cb) {
-        var command = new UpdateSecurityProfileCommand(args);
+    }
+    updateSecurityProfile(args, optionsOrCb, cb) {
+        const command = new UpdateSecurityProfileCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateStream = function (args, optionsOrCb, cb) {
-        var command = new UpdateStreamCommand(args);
+    }
+    updateStream(args, optionsOrCb, cb) {
+        const command = new UpdateStreamCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateThing = function (args, optionsOrCb, cb) {
-        var command = new UpdateThingCommand(args);
+    }
+    updateThing(args, optionsOrCb, cb) {
+        const command = new UpdateThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateThingGroup = function (args, optionsOrCb, cb) {
-        var command = new UpdateThingGroupCommand(args);
+    }
+    updateThingGroup(args, optionsOrCb, cb) {
+        const command = new UpdateThingGroupCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateThingGroupsForThing = function (args, optionsOrCb, cb) {
-        var command = new UpdateThingGroupsForThingCommand(args);
+    }
+    updateThingGroupsForThing(args, optionsOrCb, cb) {
+        const command = new UpdateThingGroupsForThingCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.updateTopicRuleDestination = function (args, optionsOrCb, cb) {
-        var command = new UpdateTopicRuleDestinationCommand(args);
+    }
+    updateTopicRuleDestination(args, optionsOrCb, cb) {
+        const command = new UpdateTopicRuleDestinationCommand(args);
         if (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);
         }
-    };
-    IoT.prototype.validateSecurityProfileBehaviors = function (args, optionsOrCb, cb) {
-        var command = new ValidateSecurityProfileBehaviorsCommand(args);
+    }
+    validateSecurityProfileBehaviors(args, optionsOrCb, cb) {
+        const command = new ValidateSecurityProfileBehaviorsCommand(args);
         if (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 IoT;
-}(IoTClient));
-export { IoT };
+    }
+}