@aws-sdk/client-comprehend 3.183.0 → 3.185.0

package/dist-es/Comprehend.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { BatchDetectDominantLanguageCommand, } from "./commands/BatchDetectDominantLanguageCommand";
 import { BatchDetectEntitiesCommand, } from "./commands/BatchDetectEntitiesCommand";
 import { BatchDetectKeyPhrasesCommand, } from "./commands/BatchDetectKeyPhrasesCommand";
@@ -72,1027 +73,1033 @@ import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateEndpointCommand, } from "./commands/UpdateEndpointCommand";
 import { ComprehendClient } from "./ComprehendClient";
-export class Comprehend extends ComprehendClient {
-    batchDetectDominantLanguage(args, optionsOrCb, cb) {
-        const command = new BatchDetectDominantLanguageCommand(args);
+var Comprehend = (function (_super) {
+    __extends(Comprehend, _super);
+    function Comprehend() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Comprehend.prototype.batchDetectDominantLanguage = function (args, optionsOrCb, cb) {
+        var command = new BatchDetectDominantLanguageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDetectEntities(args, optionsOrCb, cb) {
-        const command = new BatchDetectEntitiesCommand(args);
+    };
+    Comprehend.prototype.batchDetectEntities = function (args, optionsOrCb, cb) {
+        var command = new BatchDetectEntitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDetectKeyPhrases(args, optionsOrCb, cb) {
-        const command = new BatchDetectKeyPhrasesCommand(args);
+    };
+    Comprehend.prototype.batchDetectKeyPhrases = function (args, optionsOrCb, cb) {
+        var command = new BatchDetectKeyPhrasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDetectSentiment(args, optionsOrCb, cb) {
-        const command = new BatchDetectSentimentCommand(args);
+    };
+    Comprehend.prototype.batchDetectSentiment = function (args, optionsOrCb, cb) {
+        var command = new BatchDetectSentimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDetectSyntax(args, optionsOrCb, cb) {
-        const command = new BatchDetectSyntaxCommand(args);
+    };
+    Comprehend.prototype.batchDetectSyntax = function (args, optionsOrCb, cb) {
+        var command = new BatchDetectSyntaxCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDetectTargetedSentiment(args, optionsOrCb, cb) {
-        const command = new BatchDetectTargetedSentimentCommand(args);
+    };
+    Comprehend.prototype.batchDetectTargetedSentiment = function (args, optionsOrCb, cb) {
+        var command = new BatchDetectTargetedSentimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    classifyDocument(args, optionsOrCb, cb) {
-        const command = new ClassifyDocumentCommand(args);
+    };
+    Comprehend.prototype.classifyDocument = function (args, optionsOrCb, cb) {
+        var command = new ClassifyDocumentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    containsPiiEntities(args, optionsOrCb, cb) {
-        const command = new ContainsPiiEntitiesCommand(args);
+    };
+    Comprehend.prototype.containsPiiEntities = function (args, optionsOrCb, cb) {
+        var command = new ContainsPiiEntitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDocumentClassifier(args, optionsOrCb, cb) {
-        const command = new CreateDocumentClassifierCommand(args);
+    };
+    Comprehend.prototype.createDocumentClassifier = function (args, optionsOrCb, cb) {
+        var command = new CreateDocumentClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEndpoint(args, optionsOrCb, cb) {
-        const command = new CreateEndpointCommand(args);
+    };
+    Comprehend.prototype.createEndpoint = function (args, optionsOrCb, cb) {
+        var command = new CreateEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEntityRecognizer(args, optionsOrCb, cb) {
-        const command = new CreateEntityRecognizerCommand(args);
+    };
+    Comprehend.prototype.createEntityRecognizer = function (args, optionsOrCb, cb) {
+        var command = new CreateEntityRecognizerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDocumentClassifier(args, optionsOrCb, cb) {
-        const command = new DeleteDocumentClassifierCommand(args);
+    };
+    Comprehend.prototype.deleteDocumentClassifier = function (args, optionsOrCb, cb) {
+        var command = new DeleteDocumentClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEndpoint(args, optionsOrCb, cb) {
-        const command = new DeleteEndpointCommand(args);
+    };
+    Comprehend.prototype.deleteEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEntityRecognizer(args, optionsOrCb, cb) {
-        const command = new DeleteEntityRecognizerCommand(args);
+    };
+    Comprehend.prototype.deleteEntityRecognizer = function (args, optionsOrCb, cb) {
+        var command = new DeleteEntityRecognizerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteResourcePolicy(args, optionsOrCb, cb) {
-        const command = new DeleteResourcePolicyCommand(args);
+    };
+    Comprehend.prototype.deleteResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDocumentClassificationJob(args, optionsOrCb, cb) {
-        const command = new DescribeDocumentClassificationJobCommand(args);
+    };
+    Comprehend.prototype.describeDocumentClassificationJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeDocumentClassificationJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDocumentClassifier(args, optionsOrCb, cb) {
-        const command = new DescribeDocumentClassifierCommand(args);
+    };
+    Comprehend.prototype.describeDocumentClassifier = function (args, optionsOrCb, cb) {
+        var command = new DescribeDocumentClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeDominantLanguageDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribeDominantLanguageDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describeDominantLanguageDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeDominantLanguageDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    Comprehend.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);
         }
-    }
-    describeEntitiesDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribeEntitiesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describeEntitiesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeEntitiesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEntityRecognizer(args, optionsOrCb, cb) {
-        const command = new DescribeEntityRecognizerCommand(args);
+    };
+    Comprehend.prototype.describeEntityRecognizer = function (args, optionsOrCb, cb) {
+        var command = new DescribeEntityRecognizerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEventsDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribeEventsDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describeEventsDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeEventsDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeKeyPhrasesDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribeKeyPhrasesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describeKeyPhrasesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeKeyPhrasesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePiiEntitiesDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribePiiEntitiesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describePiiEntitiesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribePiiEntitiesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeResourcePolicy(args, optionsOrCb, cb) {
-        const command = new DescribeResourcePolicyCommand(args);
+    };
+    Comprehend.prototype.describeResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new DescribeResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeSentimentDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribeSentimentDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describeSentimentDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeSentimentDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTargetedSentimentDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribeTargetedSentimentDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describeTargetedSentimentDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeTargetedSentimentDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeTopicsDetectionJob(args, optionsOrCb, cb) {
-        const command = new DescribeTopicsDetectionJobCommand(args);
+    };
+    Comprehend.prototype.describeTopicsDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeTopicsDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detectDominantLanguage(args, optionsOrCb, cb) {
-        const command = new DetectDominantLanguageCommand(args);
+    };
+    Comprehend.prototype.detectDominantLanguage = function (args, optionsOrCb, cb) {
+        var command = new DetectDominantLanguageCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detectEntities(args, optionsOrCb, cb) {
-        const command = new DetectEntitiesCommand(args);
+    };
+    Comprehend.prototype.detectEntities = function (args, optionsOrCb, cb) {
+        var command = new DetectEntitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detectKeyPhrases(args, optionsOrCb, cb) {
-        const command = new DetectKeyPhrasesCommand(args);
+    };
+    Comprehend.prototype.detectKeyPhrases = function (args, optionsOrCb, cb) {
+        var command = new DetectKeyPhrasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detectPiiEntities(args, optionsOrCb, cb) {
-        const command = new DetectPiiEntitiesCommand(args);
+    };
+    Comprehend.prototype.detectPiiEntities = function (args, optionsOrCb, cb) {
+        var command = new DetectPiiEntitiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detectSentiment(args, optionsOrCb, cb) {
-        const command = new DetectSentimentCommand(args);
+    };
+    Comprehend.prototype.detectSentiment = function (args, optionsOrCb, cb) {
+        var command = new DetectSentimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detectSyntax(args, optionsOrCb, cb) {
-        const command = new DetectSyntaxCommand(args);
+    };
+    Comprehend.prototype.detectSyntax = function (args, optionsOrCb, cb) {
+        var command = new DetectSyntaxCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    detectTargetedSentiment(args, optionsOrCb, cb) {
-        const command = new DetectTargetedSentimentCommand(args);
+    };
+    Comprehend.prototype.detectTargetedSentiment = function (args, optionsOrCb, cb) {
+        var command = new DetectTargetedSentimentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    importModel(args, optionsOrCb, cb) {
-        const command = new ImportModelCommand(args);
+    };
+    Comprehend.prototype.importModel = function (args, optionsOrCb, cb) {
+        var command = new ImportModelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDocumentClassificationJobs(args, optionsOrCb, cb) {
-        const command = new ListDocumentClassificationJobsCommand(args);
+    };
+    Comprehend.prototype.listDocumentClassificationJobs = function (args, optionsOrCb, cb) {
+        var command = new ListDocumentClassificationJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDocumentClassifiers(args, optionsOrCb, cb) {
-        const command = new ListDocumentClassifiersCommand(args);
+    };
+    Comprehend.prototype.listDocumentClassifiers = function (args, optionsOrCb, cb) {
+        var command = new ListDocumentClassifiersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDocumentClassifierSummaries(args, optionsOrCb, cb) {
-        const command = new ListDocumentClassifierSummariesCommand(args);
+    };
+    Comprehend.prototype.listDocumentClassifierSummaries = function (args, optionsOrCb, cb) {
+        var command = new ListDocumentClassifierSummariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDominantLanguageDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListDominantLanguageDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listDominantLanguageDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListDominantLanguageDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEndpoints(args, optionsOrCb, cb) {
-        const command = new ListEndpointsCommand(args);
+    };
+    Comprehend.prototype.listEndpoints = function (args, optionsOrCb, cb) {
+        var command = new ListEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEntitiesDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListEntitiesDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listEntitiesDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListEntitiesDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEntityRecognizers(args, optionsOrCb, cb) {
-        const command = new ListEntityRecognizersCommand(args);
+    };
+    Comprehend.prototype.listEntityRecognizers = function (args, optionsOrCb, cb) {
+        var command = new ListEntityRecognizersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEntityRecognizerSummaries(args, optionsOrCb, cb) {
-        const command = new ListEntityRecognizerSummariesCommand(args);
+    };
+    Comprehend.prototype.listEntityRecognizerSummaries = function (args, optionsOrCb, cb) {
+        var command = new ListEntityRecognizerSummariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEventsDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListEventsDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listEventsDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListEventsDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listKeyPhrasesDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListKeyPhrasesDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listKeyPhrasesDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListKeyPhrasesDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPiiEntitiesDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListPiiEntitiesDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listPiiEntitiesDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListPiiEntitiesDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listSentimentDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListSentimentDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listSentimentDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListSentimentDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    Comprehend.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);
         }
-    }
-    listTargetedSentimentDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListTargetedSentimentDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listTargetedSentimentDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListTargetedSentimentDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTopicsDetectionJobs(args, optionsOrCb, cb) {
-        const command = new ListTopicsDetectionJobsCommand(args);
+    };
+    Comprehend.prototype.listTopicsDetectionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListTopicsDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putResourcePolicy(args, optionsOrCb, cb) {
-        const command = new PutResourcePolicyCommand(args);
+    };
+    Comprehend.prototype.putResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new PutResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startDocumentClassificationJob(args, optionsOrCb, cb) {
-        const command = new StartDocumentClassificationJobCommand(args);
+    };
+    Comprehend.prototype.startDocumentClassificationJob = function (args, optionsOrCb, cb) {
+        var command = new StartDocumentClassificationJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startDominantLanguageDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartDominantLanguageDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startDominantLanguageDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartDominantLanguageDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startEntitiesDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartEntitiesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startEntitiesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartEntitiesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startEventsDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartEventsDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startEventsDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartEventsDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startKeyPhrasesDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartKeyPhrasesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startKeyPhrasesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartKeyPhrasesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startPiiEntitiesDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartPiiEntitiesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startPiiEntitiesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartPiiEntitiesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startSentimentDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartSentimentDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startSentimentDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartSentimentDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startTargetedSentimentDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartTargetedSentimentDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startTargetedSentimentDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartTargetedSentimentDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startTopicsDetectionJob(args, optionsOrCb, cb) {
-        const command = new StartTopicsDetectionJobCommand(args);
+    };
+    Comprehend.prototype.startTopicsDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StartTopicsDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopDominantLanguageDetectionJob(args, optionsOrCb, cb) {
-        const command = new StopDominantLanguageDetectionJobCommand(args);
+    };
+    Comprehend.prototype.stopDominantLanguageDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StopDominantLanguageDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopEntitiesDetectionJob(args, optionsOrCb, cb) {
-        const command = new StopEntitiesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.stopEntitiesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StopEntitiesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopEventsDetectionJob(args, optionsOrCb, cb) {
-        const command = new StopEventsDetectionJobCommand(args);
+    };
+    Comprehend.prototype.stopEventsDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StopEventsDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopKeyPhrasesDetectionJob(args, optionsOrCb, cb) {
-        const command = new StopKeyPhrasesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.stopKeyPhrasesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StopKeyPhrasesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopPiiEntitiesDetectionJob(args, optionsOrCb, cb) {
-        const command = new StopPiiEntitiesDetectionJobCommand(args);
+    };
+    Comprehend.prototype.stopPiiEntitiesDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StopPiiEntitiesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopSentimentDetectionJob(args, optionsOrCb, cb) {
-        const command = new StopSentimentDetectionJobCommand(args);
+    };
+    Comprehend.prototype.stopSentimentDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StopSentimentDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopTargetedSentimentDetectionJob(args, optionsOrCb, cb) {
-        const command = new StopTargetedSentimentDetectionJobCommand(args);
+    };
+    Comprehend.prototype.stopTargetedSentimentDetectionJob = function (args, optionsOrCb, cb) {
+        var command = new StopTargetedSentimentDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopTrainingDocumentClassifier(args, optionsOrCb, cb) {
-        const command = new StopTrainingDocumentClassifierCommand(args);
+    };
+    Comprehend.prototype.stopTrainingDocumentClassifier = function (args, optionsOrCb, cb) {
+        var command = new StopTrainingDocumentClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopTrainingEntityRecognizer(args, optionsOrCb, cb) {
-        const command = new StopTrainingEntityRecognizerCommand(args);
+    };
+    Comprehend.prototype.stopTrainingEntityRecognizer = function (args, optionsOrCb, cb) {
+        var command = new StopTrainingEntityRecognizerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    Comprehend.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);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    Comprehend.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);
         }
-    }
-    updateEndpoint(args, optionsOrCb, cb) {
-        const command = new UpdateEndpointCommand(args);
+    };
+    Comprehend.prototype.updateEndpoint = function (args, optionsOrCb, cb) {
+        var command = new UpdateEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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 Comprehend;
+}(ComprehendClient));
+export { Comprehend };