@aws-sdk/client-iot 3.183.0 → 3.186.0

package/dist-es/IoT.js

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