@aws-sdk/client-iotthingsgraph 3.183.0 → 3.185.0

package/dist-es/IoTThingsGraph.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AssociateEntityToThingCommand, } from "./commands/AssociateEntityToThingCommand";
 import { CreateFlowTemplateCommand, } from "./commands/CreateFlowTemplateCommand";
 import { CreateSystemInstanceCommand, } from "./commands/CreateSystemInstanceCommand";
@@ -34,495 +35,501 @@ import { UpdateFlowTemplateCommand, } from "./commands/UpdateFlowTemplateCommand
 import { UpdateSystemTemplateCommand, } from "./commands/UpdateSystemTemplateCommand";
 import { UploadEntityDefinitionsCommand, } from "./commands/UploadEntityDefinitionsCommand";
 import { IoTThingsGraphClient } from "./IoTThingsGraphClient";
-export class IoTThingsGraph extends IoTThingsGraphClient {
-    associateEntityToThing(args, optionsOrCb, cb) {
-        const command = new AssociateEntityToThingCommand(args);
+var IoTThingsGraph = (function (_super) {
+    __extends(IoTThingsGraph, _super);
+    function IoTThingsGraph() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    IoTThingsGraph.prototype.associateEntityToThing = function (args, optionsOrCb, cb) {
+        var command = new AssociateEntityToThingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createFlowTemplate(args, optionsOrCb, cb) {
-        const command = new CreateFlowTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.createFlowTemplate = function (args, optionsOrCb, cb) {
+        var command = new CreateFlowTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSystemInstance(args, optionsOrCb, cb) {
-        const command = new CreateSystemInstanceCommand(args);
+    };
+    IoTThingsGraph.prototype.createSystemInstance = function (args, optionsOrCb, cb) {
+        var command = new CreateSystemInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSystemTemplate(args, optionsOrCb, cb) {
-        const command = new CreateSystemTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.createSystemTemplate = function (args, optionsOrCb, cb) {
+        var command = new CreateSystemTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteFlowTemplate(args, optionsOrCb, cb) {
-        const command = new DeleteFlowTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.deleteFlowTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeleteFlowTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteNamespace(args, optionsOrCb, cb) {
-        const command = new DeleteNamespaceCommand(args);
+    };
+    IoTThingsGraph.prototype.deleteNamespace = function (args, optionsOrCb, cb) {
+        var command = new DeleteNamespaceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSystemInstance(args, optionsOrCb, cb) {
-        const command = new DeleteSystemInstanceCommand(args);
+    };
+    IoTThingsGraph.prototype.deleteSystemInstance = function (args, optionsOrCb, cb) {
+        var command = new DeleteSystemInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSystemTemplate(args, optionsOrCb, cb) {
-        const command = new DeleteSystemTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.deleteSystemTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeleteSystemTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deploySystemInstance(args, optionsOrCb, cb) {
-        const command = new DeploySystemInstanceCommand(args);
+    };
+    IoTThingsGraph.prototype.deploySystemInstance = function (args, optionsOrCb, cb) {
+        var command = new DeploySystemInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deprecateFlowTemplate(args, optionsOrCb, cb) {
-        const command = new DeprecateFlowTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.deprecateFlowTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeprecateFlowTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deprecateSystemTemplate(args, optionsOrCb, cb) {
-        const command = new DeprecateSystemTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.deprecateSystemTemplate = function (args, optionsOrCb, cb) {
+        var command = new DeprecateSystemTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeNamespace(args, optionsOrCb, cb) {
-        const command = new DescribeNamespaceCommand(args);
+    };
+    IoTThingsGraph.prototype.describeNamespace = function (args, optionsOrCb, cb) {
+        var command = new DescribeNamespaceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    dissociateEntityFromThing(args, optionsOrCb, cb) {
-        const command = new DissociateEntityFromThingCommand(args);
+    };
+    IoTThingsGraph.prototype.dissociateEntityFromThing = function (args, optionsOrCb, cb) {
+        var command = new DissociateEntityFromThingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getEntities(args, optionsOrCb, cb) {
-        const command = new GetEntitiesCommand(args);
+    };
+    IoTThingsGraph.prototype.getEntities = function (args, optionsOrCb, cb) {
+        var command = new GetEntitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getFlowTemplate(args, optionsOrCb, cb) {
-        const command = new GetFlowTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.getFlowTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetFlowTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getFlowTemplateRevisions(args, optionsOrCb, cb) {
-        const command = new GetFlowTemplateRevisionsCommand(args);
+    };
+    IoTThingsGraph.prototype.getFlowTemplateRevisions = function (args, optionsOrCb, cb) {
+        var command = new GetFlowTemplateRevisionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getNamespaceDeletionStatus(args, optionsOrCb, cb) {
-        const command = new GetNamespaceDeletionStatusCommand(args);
+    };
+    IoTThingsGraph.prototype.getNamespaceDeletionStatus = function (args, optionsOrCb, cb) {
+        var command = new GetNamespaceDeletionStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSystemInstance(args, optionsOrCb, cb) {
-        const command = new GetSystemInstanceCommand(args);
+    };
+    IoTThingsGraph.prototype.getSystemInstance = function (args, optionsOrCb, cb) {
+        var command = new GetSystemInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSystemTemplate(args, optionsOrCb, cb) {
-        const command = new GetSystemTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.getSystemTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetSystemTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSystemTemplateRevisions(args, optionsOrCb, cb) {
-        const command = new GetSystemTemplateRevisionsCommand(args);
+    };
+    IoTThingsGraph.prototype.getSystemTemplateRevisions = function (args, optionsOrCb, cb) {
+        var command = new GetSystemTemplateRevisionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getUploadStatus(args, optionsOrCb, cb) {
-        const command = new GetUploadStatusCommand(args);
+    };
+    IoTThingsGraph.prototype.getUploadStatus = function (args, optionsOrCb, cb) {
+        var command = new GetUploadStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listFlowExecutionMessages(args, optionsOrCb, cb) {
-        const command = new ListFlowExecutionMessagesCommand(args);
+    };
+    IoTThingsGraph.prototype.listFlowExecutionMessages = function (args, optionsOrCb, cb) {
+        var command = new ListFlowExecutionMessagesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    IoTThingsGraph.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);
         }
-    }
-    searchEntities(args, optionsOrCb, cb) {
-        const command = new SearchEntitiesCommand(args);
+    };
+    IoTThingsGraph.prototype.searchEntities = function (args, optionsOrCb, cb) {
+        var command = new SearchEntitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    searchFlowExecutions(args, optionsOrCb, cb) {
-        const command = new SearchFlowExecutionsCommand(args);
+    };
+    IoTThingsGraph.prototype.searchFlowExecutions = function (args, optionsOrCb, cb) {
+        var command = new SearchFlowExecutionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    searchFlowTemplates(args, optionsOrCb, cb) {
-        const command = new SearchFlowTemplatesCommand(args);
+    };
+    IoTThingsGraph.prototype.searchFlowTemplates = function (args, optionsOrCb, cb) {
+        var command = new SearchFlowTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    searchSystemInstances(args, optionsOrCb, cb) {
-        const command = new SearchSystemInstancesCommand(args);
+    };
+    IoTThingsGraph.prototype.searchSystemInstances = function (args, optionsOrCb, cb) {
+        var command = new SearchSystemInstancesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    searchSystemTemplates(args, optionsOrCb, cb) {
-        const command = new SearchSystemTemplatesCommand(args);
+    };
+    IoTThingsGraph.prototype.searchSystemTemplates = function (args, optionsOrCb, cb) {
+        var command = new SearchSystemTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    searchThings(args, optionsOrCb, cb) {
-        const command = new SearchThingsCommand(args);
+    };
+    IoTThingsGraph.prototype.searchThings = function (args, optionsOrCb, cb) {
+        var command = new SearchThingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    IoTThingsGraph.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);
         }
-    }
-    undeploySystemInstance(args, optionsOrCb, cb) {
-        const command = new UndeploySystemInstanceCommand(args);
+    };
+    IoTThingsGraph.prototype.undeploySystemInstance = function (args, optionsOrCb, cb) {
+        var command = new UndeploySystemInstanceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    IoTThingsGraph.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);
         }
-    }
-    updateFlowTemplate(args, optionsOrCb, cb) {
-        const command = new UpdateFlowTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.updateFlowTemplate = function (args, optionsOrCb, cb) {
+        var command = new UpdateFlowTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateSystemTemplate(args, optionsOrCb, cb) {
-        const command = new UpdateSystemTemplateCommand(args);
+    };
+    IoTThingsGraph.prototype.updateSystemTemplate = function (args, optionsOrCb, cb) {
+        var command = new UpdateSystemTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    uploadEntityDefinitions(args, optionsOrCb, cb) {
-        const command = new UploadEntityDefinitionsCommand(args);
+    };
+    IoTThingsGraph.prototype.uploadEntityDefinitions = function (args, optionsOrCb, cb) {
+        var command = new UploadEntityDefinitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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 IoTThingsGraph;
+}(IoTThingsGraphClient));
+export { IoTThingsGraph };