@aws-sdk/client-comprehend 3.181.0 → 3.183.0

package/dist-es/Comprehend.js

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