@aws-sdk/client-transcribe 3.183.0 → 3.185.0

package/dist-es/Transcribe.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { CreateCallAnalyticsCategoryCommand, } from "./commands/CreateCallAnalyticsCategoryCommand";
 import { CreateLanguageModelCommand, } from "./commands/CreateLanguageModelCommand";
 import { CreateMedicalVocabularyCommand, } from "./commands/CreateMedicalVocabularyCommand";
@@ -38,551 +39,557 @@ import { UpdateMedicalVocabularyCommand, } from "./commands/UpdateMedicalVocabul
 import { UpdateVocabularyCommand, } from "./commands/UpdateVocabularyCommand";
 import { UpdateVocabularyFilterCommand, } from "./commands/UpdateVocabularyFilterCommand";
 import { TranscribeClient } from "./TranscribeClient";
-export class Transcribe extends TranscribeClient {
-    createCallAnalyticsCategory(args, optionsOrCb, cb) {
-        const command = new CreateCallAnalyticsCategoryCommand(args);
+var Transcribe = (function (_super) {
+    __extends(Transcribe, _super);
+    function Transcribe() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Transcribe.prototype.createCallAnalyticsCategory = function (args, optionsOrCb, cb) {
+        var command = new CreateCallAnalyticsCategoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createLanguageModel(args, optionsOrCb, cb) {
-        const command = new CreateLanguageModelCommand(args);
+    };
+    Transcribe.prototype.createLanguageModel = function (args, optionsOrCb, cb) {
+        var command = new CreateLanguageModelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createMedicalVocabulary(args, optionsOrCb, cb) {
-        const command = new CreateMedicalVocabularyCommand(args);
+    };
+    Transcribe.prototype.createMedicalVocabulary = function (args, optionsOrCb, cb) {
+        var command = new CreateMedicalVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createVocabulary(args, optionsOrCb, cb) {
-        const command = new CreateVocabularyCommand(args);
+    };
+    Transcribe.prototype.createVocabulary = function (args, optionsOrCb, cb) {
+        var command = new CreateVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createVocabularyFilter(args, optionsOrCb, cb) {
-        const command = new CreateVocabularyFilterCommand(args);
+    };
+    Transcribe.prototype.createVocabularyFilter = function (args, optionsOrCb, cb) {
+        var command = new CreateVocabularyFilterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCallAnalyticsCategory(args, optionsOrCb, cb) {
-        const command = new DeleteCallAnalyticsCategoryCommand(args);
+    };
+    Transcribe.prototype.deleteCallAnalyticsCategory = function (args, optionsOrCb, cb) {
+        var command = new DeleteCallAnalyticsCategoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCallAnalyticsJob(args, optionsOrCb, cb) {
-        const command = new DeleteCallAnalyticsJobCommand(args);
+    };
+    Transcribe.prototype.deleteCallAnalyticsJob = function (args, optionsOrCb, cb) {
+        var command = new DeleteCallAnalyticsJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteLanguageModel(args, optionsOrCb, cb) {
-        const command = new DeleteLanguageModelCommand(args);
+    };
+    Transcribe.prototype.deleteLanguageModel = function (args, optionsOrCb, cb) {
+        var command = new DeleteLanguageModelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteMedicalTranscriptionJob(args, optionsOrCb, cb) {
-        const command = new DeleteMedicalTranscriptionJobCommand(args);
+    };
+    Transcribe.prototype.deleteMedicalTranscriptionJob = function (args, optionsOrCb, cb) {
+        var command = new DeleteMedicalTranscriptionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteMedicalVocabulary(args, optionsOrCb, cb) {
-        const command = new DeleteMedicalVocabularyCommand(args);
+    };
+    Transcribe.prototype.deleteMedicalVocabulary = function (args, optionsOrCb, cb) {
+        var command = new DeleteMedicalVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTranscriptionJob(args, optionsOrCb, cb) {
-        const command = new DeleteTranscriptionJobCommand(args);
+    };
+    Transcribe.prototype.deleteTranscriptionJob = function (args, optionsOrCb, cb) {
+        var command = new DeleteTranscriptionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteVocabulary(args, optionsOrCb, cb) {
-        const command = new DeleteVocabularyCommand(args);
+    };
+    Transcribe.prototype.deleteVocabulary = function (args, optionsOrCb, cb) {
+        var command = new DeleteVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteVocabularyFilter(args, optionsOrCb, cb) {
-        const command = new DeleteVocabularyFilterCommand(args);
+    };
+    Transcribe.prototype.deleteVocabularyFilter = function (args, optionsOrCb, cb) {
+        var command = new DeleteVocabularyFilterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeLanguageModel(args, optionsOrCb, cb) {
-        const command = new DescribeLanguageModelCommand(args);
+    };
+    Transcribe.prototype.describeLanguageModel = function (args, optionsOrCb, cb) {
+        var command = new DescribeLanguageModelCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCallAnalyticsCategory(args, optionsOrCb, cb) {
-        const command = new GetCallAnalyticsCategoryCommand(args);
+    };
+    Transcribe.prototype.getCallAnalyticsCategory = function (args, optionsOrCb, cb) {
+        var command = new GetCallAnalyticsCategoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCallAnalyticsJob(args, optionsOrCb, cb) {
-        const command = new GetCallAnalyticsJobCommand(args);
+    };
+    Transcribe.prototype.getCallAnalyticsJob = function (args, optionsOrCb, cb) {
+        var command = new GetCallAnalyticsJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMedicalTranscriptionJob(args, optionsOrCb, cb) {
-        const command = new GetMedicalTranscriptionJobCommand(args);
+    };
+    Transcribe.prototype.getMedicalTranscriptionJob = function (args, optionsOrCb, cb) {
+        var command = new GetMedicalTranscriptionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMedicalVocabulary(args, optionsOrCb, cb) {
-        const command = new GetMedicalVocabularyCommand(args);
+    };
+    Transcribe.prototype.getMedicalVocabulary = function (args, optionsOrCb, cb) {
+        var command = new GetMedicalVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTranscriptionJob(args, optionsOrCb, cb) {
-        const command = new GetTranscriptionJobCommand(args);
+    };
+    Transcribe.prototype.getTranscriptionJob = function (args, optionsOrCb, cb) {
+        var command = new GetTranscriptionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getVocabulary(args, optionsOrCb, cb) {
-        const command = new GetVocabularyCommand(args);
+    };
+    Transcribe.prototype.getVocabulary = function (args, optionsOrCb, cb) {
+        var command = new GetVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getVocabularyFilter(args, optionsOrCb, cb) {
-        const command = new GetVocabularyFilterCommand(args);
+    };
+    Transcribe.prototype.getVocabularyFilter = function (args, optionsOrCb, cb) {
+        var command = new GetVocabularyFilterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCallAnalyticsCategories(args, optionsOrCb, cb) {
-        const command = new ListCallAnalyticsCategoriesCommand(args);
+    };
+    Transcribe.prototype.listCallAnalyticsCategories = function (args, optionsOrCb, cb) {
+        var command = new ListCallAnalyticsCategoriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCallAnalyticsJobs(args, optionsOrCb, cb) {
-        const command = new ListCallAnalyticsJobsCommand(args);
+    };
+    Transcribe.prototype.listCallAnalyticsJobs = function (args, optionsOrCb, cb) {
+        var command = new ListCallAnalyticsJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listLanguageModels(args, optionsOrCb, cb) {
-        const command = new ListLanguageModelsCommand(args);
+    };
+    Transcribe.prototype.listLanguageModels = function (args, optionsOrCb, cb) {
+        var command = new ListLanguageModelsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listMedicalTranscriptionJobs(args, optionsOrCb, cb) {
-        const command = new ListMedicalTranscriptionJobsCommand(args);
+    };
+    Transcribe.prototype.listMedicalTranscriptionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListMedicalTranscriptionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listMedicalVocabularies(args, optionsOrCb, cb) {
-        const command = new ListMedicalVocabulariesCommand(args);
+    };
+    Transcribe.prototype.listMedicalVocabularies = function (args, optionsOrCb, cb) {
+        var command = new ListMedicalVocabulariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    Transcribe.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);
         }
-    }
-    listTranscriptionJobs(args, optionsOrCb, cb) {
-        const command = new ListTranscriptionJobsCommand(args);
+    };
+    Transcribe.prototype.listTranscriptionJobs = function (args, optionsOrCb, cb) {
+        var command = new ListTranscriptionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listVocabularies(args, optionsOrCb, cb) {
-        const command = new ListVocabulariesCommand(args);
+    };
+    Transcribe.prototype.listVocabularies = function (args, optionsOrCb, cb) {
+        var command = new ListVocabulariesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listVocabularyFilters(args, optionsOrCb, cb) {
-        const command = new ListVocabularyFiltersCommand(args);
+    };
+    Transcribe.prototype.listVocabularyFilters = function (args, optionsOrCb, cb) {
+        var command = new ListVocabularyFiltersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startCallAnalyticsJob(args, optionsOrCb, cb) {
-        const command = new StartCallAnalyticsJobCommand(args);
+    };
+    Transcribe.prototype.startCallAnalyticsJob = function (args, optionsOrCb, cb) {
+        var command = new StartCallAnalyticsJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startMedicalTranscriptionJob(args, optionsOrCb, cb) {
-        const command = new StartMedicalTranscriptionJobCommand(args);
+    };
+    Transcribe.prototype.startMedicalTranscriptionJob = function (args, optionsOrCb, cb) {
+        var command = new StartMedicalTranscriptionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startTranscriptionJob(args, optionsOrCb, cb) {
-        const command = new StartTranscriptionJobCommand(args);
+    };
+    Transcribe.prototype.startTranscriptionJob = function (args, optionsOrCb, cb) {
+        var command = new StartTranscriptionJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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);
+    };
+    Transcribe.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);
+    };
+    Transcribe.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);
         }
-    }
-    updateCallAnalyticsCategory(args, optionsOrCb, cb) {
-        const command = new UpdateCallAnalyticsCategoryCommand(args);
+    };
+    Transcribe.prototype.updateCallAnalyticsCategory = function (args, optionsOrCb, cb) {
+        var command = new UpdateCallAnalyticsCategoryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateMedicalVocabulary(args, optionsOrCb, cb) {
-        const command = new UpdateMedicalVocabularyCommand(args);
+    };
+    Transcribe.prototype.updateMedicalVocabulary = function (args, optionsOrCb, cb) {
+        var command = new UpdateMedicalVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateVocabulary(args, optionsOrCb, cb) {
-        const command = new UpdateVocabularyCommand(args);
+    };
+    Transcribe.prototype.updateVocabulary = function (args, optionsOrCb, cb) {
+        var command = new UpdateVocabularyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateVocabularyFilter(args, optionsOrCb, cb) {
-        const command = new UpdateVocabularyFilterCommand(args);
+    };
+    Transcribe.prototype.updateVocabularyFilter = function (args, optionsOrCb, cb) {
+        var command = new UpdateVocabularyFilterCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${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 Transcribe;
+}(TranscribeClient));
+export { Transcribe };