voice-router-dev 0.8.0 → 0.8.1

package/dist/index.js

@@ -84,6 +84,13 @@ __export(src_exports, {
   DeepgramTranscriptionSchema: () => DeepgramTranscriptionSchema,
   DeepgramTypes: () => schema_exports4,
   DeepgramZodSchemas: () => deepgramAPISpecification_zod_exports,
+  ElevenLabsAdapter: () => ElevenLabsAdapter,
+  ElevenLabsCapabilities: () => ElevenLabsCapabilities,
+  ElevenLabsLanguageCodes: () => ElevenLabsLanguageCodes,
+  ElevenLabsLanguageLabels: () => ElevenLabsLanguageLabels,
+  ElevenLabsLanguages: () => ElevenLabsLanguages,
+  ElevenLabsTypes: () => schema_exports8,
+  ElevenLabsZodSchemas: () => elevenLabsSpeechToTextAPI_zod_exports,
   GladiaAdapter: () => GladiaAdapter,
   GladiaBitDepth: () => GladiaBitDepth,
   GladiaCapabilities: () => GladiaCapabilities,
@@ -170,6 +177,7 @@ __export(src_exports, {
   createAssemblyAIAdapter: () => createAssemblyAIAdapter,
   createAzureSTTAdapter: () => createAzureSTTAdapter,
   createDeepgramAdapter: () => createDeepgramAdapter,
+  createElevenLabsAdapter: () => createElevenLabsAdapter,
   createGladiaAdapter: () => createGladiaAdapter,
   createOpenAIWhisperAdapter: () => createOpenAIWhisperAdapter,
   createSonioxAdapter: () => createSonioxAdapter,
@@ -969,6 +977,7 @@ var SonioxLanguage = {
 
 // src/generated/soniox/models.ts
 var SonioxModels = [
+  { id: "stt-rt-v4", name: "Speech-to-Text Real-time v4", mode: "real_time" },
   { id: "stt-rt-v3", name: "Speech-to-Text Real-time v3", mode: "real_time" },
   { id: "stt-async-v4", name: "Speech-to-Text Async v4", mode: "async" },
   { id: "stt-async-v3", name: "Speech-to-Text Async v3", mode: "async" },
@@ -979,6 +988,7 @@ var SonioxModels = [
   { id: "stt-async-preview-v1", name: "Speech-to-Text Async Preview v1", mode: "async", aliasOf: "stt-async-v3" }
 ];
 var SonioxModelCodes = [
+  "stt-rt-v4",
   "stt-rt-v3",
   "stt-async-v4",
   "stt-async-v3",
@@ -989,6 +999,7 @@ var SonioxModelCodes = [
   "stt-async-preview-v1"
 ];
 var SonioxModelLabels = {
+  "stt-rt-v4": "Speech-to-Text Real-time v4",
   "stt-rt-v3": "Speech-to-Text Real-time v3",
   "stt-async-v4": "Speech-to-Text Async v4",
   "stt-async-v3": "Speech-to-Text Async v3",
@@ -999,6 +1010,7 @@ var SonioxModelLabels = {
   "stt-async-preview-v1": "Speech-to-Text Async Preview v1"
 };
 var SonioxModel = {
+  stt_rt_v4: "stt-rt-v4",
   stt_rt_v3: "stt-rt-v3",
   stt_async_v4: "stt-async-v4",
   stt_async_v3: "stt-async-v3",
@@ -1009,6 +1021,7 @@ var SonioxModel = {
   stt_async_preview_v1: "stt-async-preview-v1"
 };
 var SonioxRealtimeModel = {
+  stt_rt_v4: "stt-rt-v4",
   stt_rt_v3: "stt-rt-v3",
   stt_rt_preview: "stt-rt-preview",
   stt_rt_v3_preview: "stt-rt-v3-preview",
@@ -1025,6 +1038,7 @@ var SonioxAsyncModel = {
 var SpeechmaticsLanguages = [
   { code: "auto", name: "Automatic Detection" },
   { code: "ar", name: "Arabic" },
+  { code: "ar_en", name: "Arabic / English" },
   { code: "ba", name: "Bashkir" },
   { code: "be", name: "Belarusian" },
   { code: "bg", name: "Bulgarian" },
@@ -1089,6 +1103,7 @@ var SpeechmaticsLanguages = [
 var SpeechmaticsLanguageCodes = [
   "auto",
   "ar",
+  "ar_en",
   "ba",
   "be",
   "bg",
@@ -1153,6 +1168,7 @@ var SpeechmaticsLanguageCodes = [
 var SpeechmaticsLanguageLabels = {
   "auto": "Automatic Detection",
   "ar": "Arabic",
+  "ar_en": "Arabic / English",
   "ba": "Bashkir",
   "be": "Belarusian",
   "bg": "Bulgarian",
@@ -1217,6 +1233,7 @@ var SpeechmaticsLanguageLabels = {
 var SpeechmaticsLanguage = {
   "auto": "auto",
   "ar": "ar",
+  "ar_en": "ar_en",
   "ba": "ba",
   "be": "be",
   "bg": "bg",
@@ -1416,7 +1433,9 @@ var AzureLocales = [
   { code: "sl-SI", name: "Slovenian (Slovenia)" },
   { code: "so-SO", name: "Somali (Somalia)" },
   { code: "sq-AL", name: "Albanian (Albania)" },
+  { code: "sr-ME", name: "Serbian (ME)" },
   { code: "sr-RS", name: "Serbian (Serbia)" },
+  { code: "sr-XK", name: "Serbian (XK)" },
   { code: "su-ID", name: "Sundanese (Indonesia)" },
   { code: "sv-SE", name: "Swedish (Sweden)" },
   { code: "sw-KE", name: "Swahili (Kenya)" },
@@ -1571,7 +1590,9 @@ var AzureLocaleCodes = [
   "sl-SI",
   "so-SO",
   "sq-AL",
+  "sr-ME",
   "sr-RS",
+  "sr-XK",
   "su-ID",
   "sv-SE",
   "sw-KE",
@@ -1726,7 +1747,9 @@ var AzureLocaleLabels = {
   "sl-SI": "Slovenian (Slovenia)",
   "so-SO": "Somali (Somalia)",
   "sq-AL": "Albanian (Albania)",
+  "sr-ME": "Serbian (ME)",
   "sr-RS": "Serbian (Serbia)",
+  "sr-XK": "Serbian (XK)",
   "su-ID": "Sundanese (Indonesia)",
   "sv-SE": "Swedish (Sweden)",
   "sw-KE": "Swahili (Kenya)",
@@ -1881,7 +1904,9 @@ var AzureLocale = {
   "sl-SI": "sl-SI",
   "so-SO": "so-SO",
   "sq-AL": "sq-AL",
+  "sr-ME": "sr-ME",
   "sr-RS": "sr-RS",
+  "sr-XK": "sr-XK",
   "su-ID": "su-ID",
   "sv-SE": "sv-SE",
   "sw-KE": "sw-KE",
@@ -1907,6 +1932,311 @@ var AzureLocale = {
   "zu-ZA": "zu-ZA"
 };
 
+// src/generated/elevenlabs/languages.ts
+var ElevenLabsLanguages = [
+  { code: "en", name: "English" },
+  { code: "zh", name: "Chinese" },
+  { code: "de", name: "German" },
+  { code: "es", name: "Spanish" },
+  { code: "ru", name: "Russian" },
+  { code: "ko", name: "Korean" },
+  { code: "fr", name: "French" },
+  { code: "ja", name: "Japanese" },
+  { code: "pt", name: "Portuguese" },
+  { code: "tr", name: "Turkish" },
+  { code: "pl", name: "Polish" },
+  { code: "ca", name: "Catalan" },
+  { code: "nl", name: "Dutch" },
+  { code: "ar", name: "Arabic" },
+  { code: "sv", name: "Swedish" },
+  { code: "it", name: "Italian" },
+  { code: "id", name: "Indonesian" },
+  { code: "hi", name: "Hindi" },
+  { code: "fi", name: "Finnish" },
+  { code: "vi", name: "Vietnamese" },
+  { code: "he", name: "Hebrew" },
+  { code: "uk", name: "Ukrainian" },
+  { code: "el", name: "Greek" },
+  { code: "ms", name: "Malay" },
+  { code: "cs", name: "Czech" },
+  { code: "ro", name: "Romanian" },
+  { code: "da", name: "Danish" },
+  { code: "hu", name: "Hungarian" },
+  { code: "ta", name: "Tamil" },
+  { code: "no", name: "Norwegian" },
+  { code: "th", name: "Thai" },
+  { code: "ur", name: "Urdu" },
+  { code: "hr", name: "Croatian" },
+  { code: "bg", name: "Bulgarian" },
+  { code: "lt", name: "Lithuanian" },
+  { code: "la", name: "Latin" },
+  { code: "mi", name: "Maori" },
+  { code: "ml", name: "Malayalam" },
+  { code: "cy", name: "Welsh" },
+  { code: "sk", name: "Slovak" },
+  { code: "te", name: "Telugu" },
+  { code: "fa", name: "Persian" },
+  { code: "lv", name: "Latvian" },
+  { code: "bn", name: "Bengali" },
+  { code: "sr", name: "Serbian" },
+  { code: "az", name: "Azerbaijani" },
+  { code: "sl", name: "Slovenian" },
+  { code: "kn", name: "Kannada" },
+  { code: "et", name: "Estonian" },
+  { code: "mk", name: "Macedonian" },
+  { code: "br", name: "Breton" },
+  { code: "eu", name: "Basque" },
+  { code: "is", name: "Icelandic" },
+  { code: "hy", name: "Armenian" },
+  { code: "ne", name: "Nepali" },
+  { code: "mn", name: "Mongolian" },
+  { code: "bs", name: "Bosnian" },
+  { code: "kk", name: "Kazakh" },
+  { code: "sq", name: "Albanian" },
+  { code: "sw", name: "Swahili" },
+  { code: "gl", name: "Galician" },
+  { code: "mr", name: "Marathi" },
+  { code: "pa", name: "Punjabi" },
+  { code: "si", name: "Sinhala" },
+  { code: "km", name: "Khmer" },
+  { code: "sn", name: "Shona" },
+  { code: "yo", name: "Yoruba" },
+  { code: "so", name: "Somali" },
+  { code: "af", name: "Afrikaans" },
+  { code: "oc", name: "Occitan" },
+  { code: "ka", name: "Georgian" },
+  { code: "be", name: "Belarusian" },
+  { code: "tg", name: "Tajik" },
+  { code: "sd", name: "Sindhi" },
+  { code: "gu", name: "Gujarati" },
+  { code: "am", name: "Amharic" },
+  { code: "yi", name: "Yiddish" },
+  { code: "lo", name: "Lao" },
+  { code: "uz", name: "Uzbek" },
+  { code: "fo", name: "Faroese" },
+  { code: "ht", name: "Haitian Creole" },
+  { code: "ps", name: "Pashto" },
+  { code: "tk", name: "Turkmen" },
+  { code: "nn", name: "Norwegian Nynorsk" },
+  { code: "mt", name: "Maltese" },
+  { code: "sa", name: "Sanskrit" },
+  { code: "lb", name: "Luxembourgish" },
+  { code: "my", name: "Burmese" },
+  { code: "bo", name: "Tibetan" },
+  { code: "tl", name: "Tagalog" },
+  { code: "mg", name: "Malagasy" },
+  { code: "as", name: "Assamese" },
+  { code: "tt", name: "Tatar" },
+  { code: "haw", name: "Hawaiian" },
+  { code: "ln", name: "Lingala" },
+  { code: "ha", name: "Hausa" },
+  { code: "ba", name: "Bashkir" },
+  { code: "jw", name: "Javanese" },
+  { code: "su", name: "Sundanese" }
+];
+var ElevenLabsLanguageCodes = [
+  "en",
+  "zh",
+  "de",
+  "es",
+  "ru",
+  "ko",
+  "fr",
+  "ja",
+  "pt",
+  "tr",
+  "pl",
+  "ca",
+  "nl",
+  "ar",
+  "sv",
+  "it",
+  "id",
+  "hi",
+  "fi",
+  "vi",
+  "he",
+  "uk",
+  "el",
+  "ms",
+  "cs",
+  "ro",
+  "da",
+  "hu",
+  "ta",
+  "no",
+  "th",
+  "ur",
+  "hr",
+  "bg",
+  "lt",
+  "la",
+  "mi",
+  "ml",
+  "cy",
+  "sk",
+  "te",
+  "fa",
+  "lv",
+  "bn",
+  "sr",
+  "az",
+  "sl",
+  "kn",
+  "et",
+  "mk",
+  "br",
+  "eu",
+  "is",
+  "hy",
+  "ne",
+  "mn",
+  "bs",
+  "kk",
+  "sq",
+  "sw",
+  "gl",
+  "mr",
+  "pa",
+  "si",
+  "km",
+  "sn",
+  "yo",
+  "so",
+  "af",
+  "oc",
+  "ka",
+  "be",
+  "tg",
+  "sd",
+  "gu",
+  "am",
+  "yi",
+  "lo",
+  "uz",
+  "fo",
+  "ht",
+  "ps",
+  "tk",
+  "nn",
+  "mt",
+  "sa",
+  "lb",
+  "my",
+  "bo",
+  "tl",
+  "mg",
+  "as",
+  "tt",
+  "haw",
+  "ln",
+  "ha",
+  "ba",
+  "jw",
+  "su"
+];
+var ElevenLabsLanguageLabels = {
+  en: "English",
+  zh: "Chinese",
+  de: "German",
+  es: "Spanish",
+  ru: "Russian",
+  ko: "Korean",
+  fr: "French",
+  ja: "Japanese",
+  pt: "Portuguese",
+  tr: "Turkish",
+  pl: "Polish",
+  ca: "Catalan",
+  nl: "Dutch",
+  ar: "Arabic",
+  sv: "Swedish",
+  it: "Italian",
+  id: "Indonesian",
+  hi: "Hindi",
+  fi: "Finnish",
+  vi: "Vietnamese",
+  he: "Hebrew",
+  uk: "Ukrainian",
+  el: "Greek",
+  ms: "Malay",
+  cs: "Czech",
+  ro: "Romanian",
+  da: "Danish",
+  hu: "Hungarian",
+  ta: "Tamil",
+  no: "Norwegian",
+  th: "Thai",
+  ur: "Urdu",
+  hr: "Croatian",
+  bg: "Bulgarian",
+  lt: "Lithuanian",
+  la: "Latin",
+  mi: "Maori",
+  ml: "Malayalam",
+  cy: "Welsh",
+  sk: "Slovak",
+  te: "Telugu",
+  fa: "Persian",
+  lv: "Latvian",
+  bn: "Bengali",
+  sr: "Serbian",
+  az: "Azerbaijani",
+  sl: "Slovenian",
+  kn: "Kannada",
+  et: "Estonian",
+  mk: "Macedonian",
+  br: "Breton",
+  eu: "Basque",
+  is: "Icelandic",
+  hy: "Armenian",
+  ne: "Nepali",
+  mn: "Mongolian",
+  bs: "Bosnian",
+  kk: "Kazakh",
+  sq: "Albanian",
+  sw: "Swahili",
+  gl: "Galician",
+  mr: "Marathi",
+  pa: "Punjabi",
+  si: "Sinhala",
+  km: "Khmer",
+  sn: "Shona",
+  yo: "Yoruba",
+  so: "Somali",
+  af: "Afrikaans",
+  oc: "Occitan",
+  ka: "Georgian",
+  be: "Belarusian",
+  tg: "Tajik",
+  sd: "Sindhi",
+  gu: "Gujarati",
+  am: "Amharic",
+  yi: "Yiddish",
+  lo: "Lao",
+  uz: "Uzbek",
+  fo: "Faroese",
+  ht: "Haitian Creole",
+  ps: "Pashto",
+  tk: "Turkmen",
+  nn: "Norwegian Nynorsk",
+  mt: "Maltese",
+  sa: "Sanskrit",
+  lb: "Luxembourgish",
+  my: "Burmese",
+  bo: "Tibetan",
+  tl: "Tagalog",
+  mg: "Malagasy",
+  as: "Assamese",
+  tt: "Tatar",
+  haw: "Hawaiian",
+  ln: "Lingala",
+  ha: "Hausa",
+  ba: "Bashkir",
+  jw: "Javanese",
+  su: "Sundanese"
+};
+
 // src/generated/gladia/schema/streamingSupportedBitDepthEnum.ts
 var StreamingSupportedBitDepthEnum = {
   NUMBER_8: 8,
@@ -2448,6 +2778,16 @@ var DeepgramSampleRate = {
   NUMBER_44100: 44100,
   NUMBER_48000: 48e3
 };
+var ElevenLabsRegion = {
+  /** Global endpoint (default) */
+  global: "global",
+  /** United States */
+  us: "us",
+  /** European Union */
+  eu: "eu",
+  /** India */
+  in: "in"
+};
 var GladiaEncoding = StreamingSupportedEncodingEnum;
 var GladiaSampleRate = StreamingSupportedSampleRateEnum;
 var GladiaBitDepth = StreamingSupportedBitDepthEnum;
@@ -2866,6 +3206,70 @@ function extractWords(words, mapper) {
   const normalizedWords = words.map(mapper);
   return normalizedWords.length > 0 ? normalizedWords : void 0;
 }
+function buildUtterancesFromWords(words) {
+  const utterances = [];
+  let currentSpeaker;
+  let currentWords = [];
+  let utteranceStart = 0;
+  for (const word of words) {
+    if (!word.speaker) continue;
+    if (word.speaker !== currentSpeaker) {
+      if (currentSpeaker && currentWords.length > 0) {
+        utterances.push({
+          text: currentWords.map((w) => w.word).join(" "),
+          start: utteranceStart,
+          end: currentWords[currentWords.length - 1].end,
+          speaker: currentSpeaker,
+          words: currentWords
+        });
+      }
+      currentSpeaker = word.speaker;
+      currentWords = [word];
+      utteranceStart = word.start;
+    } else {
+      currentWords.push(word);
+    }
+  }
+  if (currentSpeaker && currentWords.length > 0) {
+    utterances.push({
+      text: currentWords.map((w) => w.word).join(" "),
+      start: utteranceStart,
+      end: currentWords[currentWords.length - 1].end,
+      speaker: currentSpeaker,
+      words: currentWords
+    });
+  }
+  return utterances;
+}
+function buildTextFromSpeechmaticsResults(results) {
+  const parts = [];
+  let attachNext = false;
+  for (const result of results) {
+    if (result.type !== "word" && result.type !== "punctuation") continue;
+    const content = result.alternatives?.[0]?.content;
+    if (!content) continue;
+    if (result.type === "punctuation") {
+      const attaches = result.attaches_to;
+      if (attaches === "previous" || attaches === "both") {
+        parts.push(content);
+        attachNext = attaches === "both";
+      } else if (attaches === "next") {
+        if (parts.length > 0) parts.push(" ");
+        parts.push(content);
+        attachNext = true;
+      } else {
+        if (parts.length > 0 && !attachNext) parts.push(" ");
+        parts.push(content);
+        attachNext = false;
+      }
+    } else {
+      if (parts.length > 0 && !attachNext) parts.push(" ");
+      parts.push(content);
+      attachNext = false;
+    }
+  }
+  return parts.join("");
+}
 var STATUS_MAPPINGS = {
   gladia: {
     queued: "queued",
@@ -6482,7 +6886,7 @@ var DeepgramAdapter = class extends BaseAdapter {
         start: w.start || 0,
         end: w.end || 0,
         confidence: w.confidence
-      }))
+      })) ?? []
     }));
   }
   /**
@@ -6891,7 +7295,7 @@ var DeepgramAdapter = class extends BaseAdapter {
               start: w.start,
               end: w.end,
               confidence: w.confidence
-            }))
+            })) ?? []
           });
         }
         break;
@@ -8130,7 +8534,8 @@ var OpenAIWhisperAdapter = class extends BaseAdapter {
         callbacks?.onUtterance?.({
           text: transcription.transcript,
           start: 0,
-          end: 0
+          end: 0,
+          words: []
         });
         break;
       }
@@ -8193,7 +8598,8 @@ var OpenAIWhisperAdapter = class extends BaseAdapter {
         text: segment.text,
         start: segment.start,
         end: segment.end,
-        confidence: void 0
+        confidence: void 0,
+        words: []
       }));
       const requestId2 = `openai-${Date.now()}`;
       return {
@@ -8559,7 +8965,7 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
    * Normalize Speechmatics response to unified format
    */
   normalizeResponse(response) {
-    const text = response.results.filter((r) => r.type === "word" && r.alternatives).map((r) => r.alternatives[0]?.content || "").join(" ");
+    const text = buildTextFromSpeechmaticsResults(response.results);
     const words = response.results.filter((r) => r.type === "word" && r.start_time !== void 0 && r.end_time !== void 0).map((result) => ({
       word: result.alternatives?.[0]?.content || "",
       start: result.start_time,
@@ -8568,51 +8974,14 @@ var SpeechmaticsAdapter = class extends BaseAdapter {
       speaker: result.alternatives?.[0]?.speaker
     }));
     const speakerSet = /* @__PURE__ */ new Set();
-    response.results.forEach((r) => {
-      if (r.alternatives) {
-        const speaker = r.alternatives[0]?.speaker;
-        if (speaker) speakerSet.add(speaker);
-      }
+    words.forEach((w) => {
+      if (w.speaker) speakerSet.add(w.speaker);
     });
     const speakers = speakerSet.size > 0 ? Array.from(speakerSet).map((id) => ({
       id,
       label: `Speaker ${id}`
     })) : void 0;
-    const utterances = [];
-    if (speakers) {
-      let currentSpeaker;
-      let currentUtterance = [];
-      let utteranceStart = 0;
-      response.results.filter((r) => r.type === "word" && r.alternatives).forEach((result, idx) => {
-        const speaker = result.alternatives[0]?.speaker;
-        const word = result.alternatives[0]?.content || "";
-        if (speaker !== currentSpeaker) {
-          if (currentSpeaker && currentUtterance.length > 0) {
-            const prevResult = response.results.filter((r) => r.type === "word")[idx - 1];
-            utterances.push({
-              speaker: currentSpeaker,
-              text: currentUtterance.join(" "),
-              start: utteranceStart || 0,
-              end: prevResult?.end_time || result.start_time || 0
-            });
-          }
-          currentSpeaker = speaker;
-          currentUtterance = [word];
-          utteranceStart = result.start_time || 0;
-        } else {
-          currentUtterance.push(word);
-        }
-      });
-      if (currentSpeaker && currentUtterance.length > 0) {
-        const lastWord = response.results.filter((r) => r.type === "word").pop();
-        utterances.push({
-          speaker: currentSpeaker,
-          text: currentUtterance.join(" "),
-          start: utteranceStart,
-          end: lastWord?.end_time || utteranceStart
-        });
-      }
-    }
+    const utterances = buildUtterancesFromWords(words);
     return {
       success: true,
       provider: this.name,
@@ -9134,45 +9503,14 @@ var SonioxAdapter = class extends BaseAdapter {
    * Build utterances from tokens based on speaker changes
    */
   buildUtterancesFromTokens(tokens) {
-    const utterances = [];
-    let currentSpeaker;
-    let currentWords = [];
-    let utteranceStart = 0;
-    for (const token of tokens) {
-      const word = {
-        word: token.text,
-        start: token.start_ms ? token.start_ms / 1e3 : 0,
-        end: token.end_ms ? token.end_ms / 1e3 : 0,
-        confidence: token.confidence,
-        speaker: token.speaker
-      };
-      if (token.speaker !== currentSpeaker) {
-        if (currentSpeaker && currentWords.length > 0) {
-          utterances.push({
-            text: currentWords.map((w) => w.word).join(" "),
-            start: utteranceStart,
-            end: currentWords[currentWords.length - 1].end,
-            speaker: currentSpeaker,
-            words: currentWords
-          });
-        }
-        currentSpeaker = token.speaker;
-        currentWords = [word];
-        utteranceStart = word.start;
-      } else {
-        currentWords.push(word);
-      }
-    }
-    if (currentSpeaker && currentWords.length > 0) {
-      utterances.push({
-        text: currentWords.map((w) => w.word).join(" "),
-        start: utteranceStart,
-        end: currentWords[currentWords.length - 1].end,
-        speaker: currentSpeaker,
-        words: currentWords
-      });
-    }
-    return utterances;
+    const words = tokens.map((token) => ({
+      word: token.text,
+      start: token.start_ms ? token.start_ms / 1e3 : 0,
+      end: token.end_ms ? token.end_ms / 1e3 : 0,
+      confidence: token.confidence,
+      speaker: token.speaker
+    }));
+    return buildUtterancesFromWords(words);
   }
   /**
    * Normalize Soniox response to unified format
@@ -9196,7 +9534,7 @@ var SonioxAdapter = class extends BaseAdapter {
       id,
       label: `Speaker ${id}`
     })) : void 0;
-    const utterances = response.tokens ? this.buildUtterancesFromTokens(response.tokens) : [];
+    const utterances = response.tokens ? this.buildUtterancesFromTokens(response.tokens.filter((t) => t.is_final)) : [];
     const language = response.tokens?.find((t) => t.language)?.language;
     return {
       success: true,
@@ -9225,6 +9563,501 @@ function createSonioxAdapter(config) {
   return adapter;
 }
 
+// src/adapters/elevenlabs-adapter.ts
+var import_axios10 = __toESM(require("axios"));
+var ElevenLabsAdapter = class extends BaseAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "elevenlabs";
+    this.capabilities = {
+      streaming: true,
+      diarization: true,
+      wordTimestamps: true,
+      languageDetection: true,
+      customVocabulary: true,
+      summarization: false,
+      sentimentAnalysis: false,
+      entityDetection: true,
+      piiRedaction: true,
+      listTranscripts: false,
+      deleteTranscript: false
+    };
+    this.region = ElevenLabsRegion.global;
+    this.defaultModel = "scribe_v2";
+  }
+  /**
+   * Get regional API host based on configured region
+   */
+  getRegionalHost() {
+    switch (this.region) {
+      case ElevenLabsRegion.us:
+        return "api.us.elevenlabs.io";
+      case ElevenLabsRegion.eu:
+        return "api.eu.residency.elevenlabs.io";
+      case ElevenLabsRegion.in:
+        return "api.in.residency.elevenlabs.io";
+      case ElevenLabsRegion.global:
+      default:
+        return "api.elevenlabs.io";
+    }
+  }
+  /**
+   * Get the base URL for API requests
+   */
+  get baseUrl() {
+    if (this.config?.baseUrl) return this.config.baseUrl;
+    return `https://${this.getRegionalHost()}`;
+  }
+  initialize(config) {
+    super.initialize(config);
+    if (config.region) {
+      this.region = config.region;
+    }
+    if (config.model) {
+      this.defaultModel = config.model;
+    }
+    this.client = import_axios10.default.create({
+      baseURL: this.baseUrl,
+      timeout: config.timeout || 12e4,
+      headers: {
+        "xi-api-key": config.apiKey,
+        ...config.headers
+      }
+    });
+  }
+  /**
+   * Get current region
+   */
+  getRegion() {
+    return this.region;
+  }
+  /**
+   * Set regional endpoint
+   */
+  setRegion(region) {
+    this.region = region;
+    if (this.config?.apiKey) {
+      this.client = import_axios10.default.create({
+        baseURL: this.baseUrl,
+        timeout: this.config.timeout || 12e4,
+        headers: {
+          "xi-api-key": this.config.apiKey,
+          ...this.config.headers
+        }
+      });
+    }
+  }
+  /**
+   * Submit audio for transcription
+   *
+   * ElevenLabs batch is synchronous - the API returns the result directly.
+   */
+  async transcribe(audio, options) {
+    this.validateConfig();
+    try {
+      const formData = new FormData();
+      const modelId = options?.model || this.defaultModel;
+      formData.append("model_id", modelId);
+      if (audio.type === "url") {
+        formData.append("cloud_storage_url", audio.url);
+      } else if (audio.type === "file") {
+        const audioBlob = audio.file instanceof Blob ? audio.file : new Blob([audio.file], { type: audio.mimeType || "audio/wav" });
+        formData.append("file", audioBlob, audio.filename || "audio.wav");
+      } else {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "INVALID_INPUT",
+            message: "ElevenLabs only supports URL and File audio input"
+          }
+        };
+      }
+      if (options?.language) {
+        formData.append("language_code", options.language);
+      }
+      if (options?.diarization) {
+        formData.append("diarize", "true");
+      }
+      formData.append("timestamps_granularity", "word");
+      if (options?.speakersExpected) {
+        formData.append("num_speakers", String(options.speakersExpected));
+      }
+      if (options?.customVocabulary && options.customVocabulary.length > 0) {
+        for (const term of options.customVocabulary) {
+          formData.append("keyterms", term);
+        }
+      }
+      if (options?.entityDetection) {
+        formData.append("entity_detection", "all");
+      }
+      const elevenlabsOpts = options?.elevenlabs;
+      if (elevenlabsOpts) {
+        for (const [key, value] of Object.entries(elevenlabsOpts)) {
+          if (value === void 0 || value === null) continue;
+          if (formData.has(key)) continue;
+          if (typeof value === "boolean") {
+            formData.append(key, String(value));
+          } else if (Array.isArray(value)) {
+            for (const item of value) {
+              formData.append(key, typeof item === "object" ? JSON.stringify(item) : String(item));
+            }
+          } else if (typeof value === "object") {
+            formData.append(key, JSON.stringify(value));
+          } else {
+            formData.append(key, String(value));
+          }
+        }
+      }
+      const response = await this.client.post("/v1/speech-to-text", formData, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+      return this.normalizeResponse(response.data);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Get transcription result by ID
+   *
+   * ElevenLabs batch is synchronous, but supports transcript retrieval.
+   */
+  async getTranscript(transcriptId) {
+    this.validateConfig();
+    try {
+      const response = await this.client.get(`/v1/speech-to-text/transcripts/${transcriptId}`);
+      return this.normalizeResponse(response.data);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Stream audio for real-time transcription
+   *
+   * Creates a WebSocket connection to ElevenLabs realtime STT endpoint.
+   * Audio is sent as base64-encoded JSON messages.
+   */
+  async transcribeStream(options, callbacks) {
+    this.validateConfig();
+    const sessionId = `elevenlabs_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const createdAt = /* @__PURE__ */ new Date();
+    const wsBase = this.config?.wsBaseUrl || (this.config?.baseUrl ? this.deriveWsUrl(this.config.baseUrl) : `wss://${this.getRegionalHost()}`);
+    const wsUrl = new URL(`${wsBase}/v1/speech-to-text/realtime`);
+    const elOpts = options?.elevenlabsStreaming;
+    const modelId = elOpts?.model || "scribe_v2_realtime";
+    wsUrl.searchParams.set("model_id", modelId);
+    const audioFormat = elOpts?.audioFormat || "pcm_16000";
+    wsUrl.searchParams.set("audio_format", audioFormat);
+    const langCode = elOpts?.languageCode || options?.language;
+    if (langCode) {
+      wsUrl.searchParams.set("language_code", langCode);
+    }
+    if (elOpts?.includeTimestamps !== void 0) {
+      wsUrl.searchParams.set("include_timestamps", String(elOpts.includeTimestamps));
+    }
+    if (elOpts?.includeLanguageDetection || options?.languageDetection) {
+      wsUrl.searchParams.set("include_language_detection", "true");
+    }
+    if (elOpts?.commitStrategy) {
+      wsUrl.searchParams.set("commit_strategy", elOpts.commitStrategy);
+    }
+    if (elOpts?.vadSilenceThresholdSecs !== void 0) {
+      wsUrl.searchParams.set("vad_silence_threshold_secs", String(elOpts.vadSilenceThresholdSecs));
+    }
+    if (elOpts?.vadThreshold !== void 0) {
+      wsUrl.searchParams.set("vad_threshold", String(elOpts.vadThreshold));
+    }
+    if (elOpts?.minSpeechDurationMs !== void 0) {
+      wsUrl.searchParams.set("min_speech_duration_ms", String(elOpts.minSpeechDurationMs));
+    }
+    if (elOpts?.minSilenceDurationMs !== void 0) {
+      wsUrl.searchParams.set("min_silence_duration_ms", String(elOpts.minSilenceDurationMs));
+    }
+    if (elOpts?.previousText) {
+      wsUrl.searchParams.set("previous_text", elOpts.previousText);
+    }
+    if (!elOpts?.audioFormat && options?.encoding) {
+      const encodingMap = {
+        linear16: "pcm_16000",
+        pcm: "pcm_16000",
+        mulaw: "ulaw_8000"
+      };
+      const mappedFormat = encodingMap[options.encoding];
+      if (mappedFormat) {
+        wsUrl.searchParams.set("audio_format", mappedFormat);
+      }
+    }
+    let status = "connecting";
+    let openedAt = null;
+    let receivedData = false;
+    const WebSocketImpl = typeof WebSocket !== "undefined" ? WebSocket : require("ws");
+    const ws = new WebSocketImpl(wsUrl.toString(), {
+      headers: {
+        "xi-api-key": this.config.apiKey
+      }
+    });
+    ws.onopen = () => {
+      status = "open";
+      openedAt = Date.now();
+      callbacks?.onOpen?.();
+    };
+    ws.onmessage = (event) => {
+      receivedData = true;
+      const rawPayload = typeof event.data === "string" ? event.data : event.data.toString();
+      let messageType;
+      try {
+        const data = JSON.parse(rawPayload);
+        if (data.error) {
+          messageType = "error";
+        } else if (data.message_type === "session_started") {
+          messageType = "session_started";
+        } else if (data.message_type === "partial_transcript") {
+          messageType = "partial_transcript";
+        } else if (data.message_type === "committed_transcript") {
+          messageType = "committed_transcript";
+        } else if (data.message_type === "committed_transcript_with_timestamps") {
+          messageType = "committed_transcript_with_timestamps";
+        }
+        if (callbacks?.onRawMessage) {
+          callbacks.onRawMessage({
+            provider: this.name,
+            direction: "incoming",
+            timestamp: Date.now(),
+            payload: rawPayload,
+            messageType
+          });
+        }
+        if (data.error) {
+          callbacks?.onError?.({
+            code: data.error_code?.toString() || "STREAM_ERROR",
+            message: data.error
+          });
+          return;
+        }
+        if (data.message_type === "session_started") {
+          return;
+        }
+        if (data.message_type === "partial_transcript") {
+          const streamEvent = {
+            type: "transcript",
+            text: data.text || "",
+            isFinal: false,
+            confidence: void 0,
+            language: data.language_code
+          };
+          callbacks?.onTranscript?.(streamEvent);
+          return;
+        }
+        if (data.message_type === "committed_transcript" || data.message_type === "committed_transcript_with_timestamps") {
+          const words = data.words ? data.words.map((w) => ({
+            word: w.text || "",
+            start: w.start || 0,
+            end: w.end || 0,
+            confidence: w.logprob !== void 0 ? Math.exp(w.logprob) : void 0,
+            speaker: w.speaker_id
+          })) : [];
+          const streamEvent = {
+            type: "transcript",
+            text: data.text || "",
+            isFinal: true,
+            words: words.length > 0 ? words : void 0,
+            speaker: words[0]?.speaker,
+            language: data.language_code,
+            confidence: void 0
+          };
+          callbacks?.onTranscript?.(streamEvent);
+          if (options?.diarization && words.length > 0) {
+            const utterances = buildUtterancesFromWords(words);
+            for (const utterance of utterances) {
+              callbacks?.onUtterance?.(utterance);
+            }
+          }
+        }
+      } catch (error) {
+        callbacks?.onError?.({
+          code: "PARSE_ERROR",
+          message: `Failed to parse message: ${error}`
+        });
+      }
+    };
+    ws.onerror = () => {
+      callbacks?.onError?.({
+        code: "WEBSOCKET_ERROR",
+        message: "WebSocket error occurred"
+      });
+    };
+    ws.onclose = (event) => {
+      status = "closed";
+      const timeSinceOpen = openedAt ? Date.now() - openedAt : null;
+      const isImmediateClose = timeSinceOpen !== null && timeSinceOpen < 1e3 && !receivedData;
+      if (isImmediateClose && event.code === 1e3) {
+        callbacks?.onError?.({
+          code: "ELEVENLABS_CONFIG_REJECTED",
+          message: [
+            "ElevenLabs closed connection immediately after opening.",
+            `Current config: region=${this.region}, model=${modelId}`,
+            "Likely causes:",
+            "  - Invalid API key",
+            "  - Unsupported audio format or model",
+            event.reason ? `Server reason: ${event.reason}` : null
+          ].filter(Boolean).join("\n")
+        });
+      }
+      callbacks?.onClose?.(event.code, event.reason);
+    };
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("WebSocket connection timeout"));
+      }, 1e4);
+      const checkOpen = () => {
+        if (status === "open") {
+          clearTimeout(timeout);
+          resolve();
+        } else if (status === "closed") {
+          clearTimeout(timeout);
+          reject(new Error("WebSocket connection failed"));
+        } else {
+          setTimeout(checkOpen, 100);
+        }
+      };
+      checkOpen();
+    });
+    return {
+      id: sessionId,
+      provider: this.name,
+      createdAt,
+      getStatus: () => status,
+      sendAudio: async (chunk) => {
+        if (status !== "open") {
+          throw new Error("Session is not open");
+        }
+        let base64Audio;
+        if (chunk.data instanceof ArrayBuffer) {
+          base64Audio = Buffer.from(chunk.data).toString("base64");
+        } else if (chunk.data instanceof Uint8Array) {
+          base64Audio = Buffer.from(
+            chunk.data.buffer,
+            chunk.data.byteOffset,
+            chunk.data.byteLength
+          ).toString("base64");
+        } else {
+          base64Audio = Buffer.from(chunk.data).toString("base64");
+        }
+        const message = JSON.stringify({
+          message_type: "input_audio_chunk",
+          audio_base_64: base64Audio
+        });
+        if (callbacks?.onRawMessage) {
+          callbacks.onRawMessage({
+            provider: this.name,
+            direction: "outgoing",
+            timestamp: Date.now(),
+            payload: message,
+            messageType: "audio"
+          });
+        }
+        ws.send(message);
+      },
+      close: async () => {
+        if (status === "open") {
+          status = "closing";
+          ws.send(JSON.stringify({ message_type: "end_of_stream" }));
+          ws.close(1e3, "Client requested close");
+        }
+      }
+    };
+  }
+  /**
+   * Normalize ElevenLabs response to unified format
+   *
+   * ElevenLabs returns either:
+   * - Single channel: `SpeechToTextChunkResponseModel` directly (text, words, etc.)
+   * - Multi-channel: `MultichannelSpeechToTextResponseModel` with `transcripts[]`
+   */
+  normalizeResponse(response) {
+    const chunks = response.transcripts ? response.transcripts : [response];
+    const text = chunks.map((c) => c.text).join(" ");
+    const words = [];
+    const speakerSet = /* @__PURE__ */ new Set();
+    const audioEvents = [];
+    for (const chunk of chunks) {
+      if (!chunk.words) continue;
+      for (const w of chunk.words) {
+        if (w.type === "audio_event") {
+          audioEvents.push({
+            text: w.text,
+            start: typeof w.start === "number" ? w.start : 0,
+            end: typeof w.end === "number" ? w.end : 0
+          });
+          continue;
+        }
+        const speakerId = w.speaker_id ?? void 0;
+        const word = {
+          word: w.text,
+          start: typeof w.start === "number" ? w.start : 0,
+          end: typeof w.end === "number" ? w.end : 0,
+          confidence: w.logprob !== void 0 ? Math.exp(w.logprob) : void 0,
+          speaker: speakerId ?? void 0
+        };
+        words.push(word);
+        if (speakerId) {
+          speakerSet.add(speakerId);
+        }
+      }
+    }
+    const speakers = speakerSet.size > 0 ? Array.from(speakerSet).map((id) => ({
+      id,
+      label: `Speaker ${id}`
+    })) : void 0;
+    const utterances = words.length > 0 ? buildUtterancesFromWords(words) : [];
+    const language = chunks[0]?.language_code;
+    const languageProbability = chunks[0]?.language_probability;
+    const entities = [];
+    for (const chunk of chunks) {
+      if (chunk.entities && Array.isArray(chunk.entities)) {
+        for (const entity of chunk.entities) {
+          entities.push({
+            text: entity.text,
+            entity_type: entity.entity_type,
+            start_char: entity.start_char,
+            end_char: entity.end_char
+          });
+        }
+      }
+    }
+    const transcriptionId = response.transcription_id || chunks[0]?.transcription_id || `elevenlabs_${Date.now()}`;
+    return {
+      success: true,
+      provider: this.name,
+      data: {
+        id: transcriptionId,
+        text,
+        status: "completed",
+        language,
+        speakers,
+        words: words.length > 0 ? words : void 0,
+        utterances: utterances.length > 0 ? utterances : void 0
+      },
+      extended: {
+        entities: entities.length > 0 ? entities : void 0,
+        audioEvents: audioEvents.length > 0 ? audioEvents : void 0,
+        languageProbability
+      },
+      tracking: {
+        requestId: transcriptionId
+      },
+      raw: response
+    };
+  }
+};
+function createElevenLabsAdapter(config) {
+  const adapter = new ElevenLabsAdapter();
+  adapter.initialize(config);
+  return adapter;
+}
+
 // src/utils/zod-to-field-configs.ts
 function unwrapZodType(schema) {
   let inner = schema;
@@ -36625,6 +37458,21 @@ var SonioxCapabilities = {
   listTranscripts: false,
   deleteTranscript: false
 };
+var ElevenLabsCapabilities = {
+  streaming: true,
+  diarization: true,
+  wordTimestamps: true,
+  languageDetection: true,
+  customVocabulary: true,
+  // Via keyterms parameter
+  summarization: false,
+  sentimentAnalysis: false,
+  entityDetection: true,
+  piiRedaction: true,
+  // Via entity_detection with PII categories
+  listTranscripts: false,
+  deleteTranscript: false
+};
 var ProviderCapabilitiesMap = {
   gladia: GladiaCapabilities,
   assemblyai: AssemblyAICapabilities,
@@ -36632,7 +37480,8 @@ var ProviderCapabilitiesMap = {
   "openai-whisper": OpenAICapabilities,
   "azure-stt": AzureCapabilities,
   speechmatics: SpeechmaticsCapabilities,
-  soniox: SonioxCapabilities
+  soniox: SonioxCapabilities,
+  elevenlabs: ElevenLabsCapabilities
 };
 var CapabilityKeys = [
   "streaming",
@@ -36834,7 +37683,8 @@ var AllLanguageCodes = {
   // BCP-47 locale codes (e.g., "en-US")
   speechmatics: SpeechmaticsLanguageCodes,
   // ISO 639-1 codes with multilingual packs
-  soniox: SonioxLanguageCodes
+  soniox: SonioxLanguageCodes,
+  elevenlabs: ElevenLabsLanguageCodes
 };
 var ProviderDisplayNames = {
   gladia: "Gladia",
@@ -36843,7 +37693,8 @@ var ProviderDisplayNames = {
   "openai-whisper": "OpenAI Whisper",
   "azure-stt": "Azure Speech",
   speechmatics: "Speechmatics",
-  soniox: "Soniox"
+  soniox: "Soniox",
+  elevenlabs: "ElevenLabs"
 };
 var ProviderWebsites = {
   gladia: "https://gladia.io",
@@ -36852,7 +37703,8 @@ var ProviderWebsites = {
   "openai-whisper": "https://openai.com",
   "azure-stt": "https://azure.microsoft.com/services/cognitive-services/speech-to-text/",
   speechmatics: "https://speechmatics.com",
-  soniox: "https://soniox.com"
+  soniox: "https://soniox.com",
+  elevenlabs: "https://elevenlabs.io"
 };
 var ProviderDocs = {
   gladia: "https://docs.gladia.io",
@@ -36861,7 +37713,8 @@ var ProviderDocs = {
   "openai-whisper": "https://platform.openai.com/docs/guides/speech-to-text",
   "azure-stt": "https://learn.microsoft.com/azure/cognitive-services/speech-service/",
   speechmatics: "https://docs.speechmatics.com",
-  soniox: "https://soniox.com/docs/stt/"
+  soniox: "https://soniox.com/docs/stt/",
+  elevenlabs: "https://elevenlabs.io/docs/capabilities/speech-to-text"
 };
 var AllProviders = [
   "gladia",
@@ -36870,7 +37723,8 @@ var AllProviders = [
   "openai-whisper",
   "azure-stt",
   "speechmatics",
-  "soniox"
+  "soniox",
+  "elevenlabs"
 ];
 var StreamingProviders = AllProviders.filter(
   (p) => ProviderCapabilitiesMap[p].streaming
@@ -37595,6 +38449,77 @@ var TranslationConfigType = {
   two_way: "two_way"
 };
 
+// src/generated/elevenlabs/schema/index.ts
+var schema_exports8 = {};
+__export(schema_exports8, {
+  BodySpeechToTextV1SpeechToTextPostFileFormat: () => BodySpeechToTextV1SpeechToTextPostFileFormat,
+  BodySpeechToTextV1SpeechToTextPostModelId: () => BodySpeechToTextV1SpeechToTextPostModelId,
+  BodySpeechToTextV1SpeechToTextPostTimestampsGranularity: () => BodySpeechToTextV1SpeechToTextPostTimestampsGranularity,
+  DocxExportOptionsFormat: () => DocxExportOptionsFormat,
+  HtmlExportOptionsFormat: () => HtmlExportOptionsFormat,
+  PdfExportOptionsFormat: () => PdfExportOptionsFormat,
+  SegmentedJsonExportOptionsFormat: () => SegmentedJsonExportOptionsFormat,
+  SpeechToTextWordResponseModelType: () => SpeechToTextWordResponseModelType,
+  SrtExportOptionsFormat: () => SrtExportOptionsFormat,
+  TxtExportOptionsFormat: () => TxtExportOptionsFormat
+});
+
+// src/generated/elevenlabs/schema/bodySpeechToTextV1SpeechToTextPostFileFormat.ts
+var BodySpeechToTextV1SpeechToTextPostFileFormat = {
+  pcm_s16le_16: "pcm_s16le_16",
+  other: "other"
+};
+
+// src/generated/elevenlabs/schema/bodySpeechToTextV1SpeechToTextPostModelId.ts
+var BodySpeechToTextV1SpeechToTextPostModelId = {
+  scribe_v1: "scribe_v1",
+  scribe_v2: "scribe_v2"
+};
+
+// src/generated/elevenlabs/schema/bodySpeechToTextV1SpeechToTextPostTimestampsGranularity.ts
+var BodySpeechToTextV1SpeechToTextPostTimestampsGranularity = {
+  none: "none",
+  word: "word",
+  character: "character"
+};
+
+// src/generated/elevenlabs/schema/docxExportOptionsFormat.ts
+var DocxExportOptionsFormat = {
+  docx: "docx"
+};
+
+// src/generated/elevenlabs/schema/htmlExportOptionsFormat.ts
+var HtmlExportOptionsFormat = {
+  html: "html"
+};
+
+// src/generated/elevenlabs/schema/pdfExportOptionsFormat.ts
+var PdfExportOptionsFormat = {
+  pdf: "pdf"
+};
+
+// src/generated/elevenlabs/schema/segmentedJsonExportOptionsFormat.ts
+var SegmentedJsonExportOptionsFormat = {
+  segmented_json: "segmented_json"
+};
+
+// src/generated/elevenlabs/schema/speechToTextWordResponseModelType.ts
+var SpeechToTextWordResponseModelType = {
+  word: "word",
+  spacing: "spacing",
+  audio_event: "audio_event"
+};
+
+// src/generated/elevenlabs/schema/srtExportOptionsFormat.ts
+var SrtExportOptionsFormat = {
+  srt: "srt"
+};
+
+// src/generated/elevenlabs/schema/txtExportOptionsFormat.ts
+var TxtExportOptionsFormat = {
+  txt: "txt"
+};
+
 // src/generated/speechmatics/api/speechmaticsASRRESTAPI.zod.ts
 var speechmaticsASRRESTAPI_zod_exports = {};
 __export(speechmaticsASRRESTAPI_zod_exports, {
@@ -38707,6 +39632,448 @@ var getUsageResponse = import_zod12.z.object({
     })
   )
 });
+
+// src/generated/elevenlabs/api/elevenLabsSpeechToTextAPI.zod.ts
+var elevenLabsSpeechToTextAPI_zod_exports = {};
+__export(elevenLabsSpeechToTextAPI_zod_exports, {
+  deleteTranscriptByIdHeader: () => deleteTranscriptByIdHeader,
+  deleteTranscriptByIdParams: () => deleteTranscriptByIdParams,
+  deleteTranscriptByIdResponse: () => deleteTranscriptByIdResponse,
+  getTranscriptByIdHeader: () => getTranscriptByIdHeader,
+  getTranscriptByIdParams: () => getTranscriptByIdParams,
+  getTranscriptByIdResponse: () => getTranscriptByIdResponse,
+  speechToTextBody: () => speechToTextBody,
+  speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefault: () => speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefault,
+  speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultFive: () => speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultFive,
+  speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultFour: () => speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultFour,
+  speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultOne: () => speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultOne,
+  speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultThree: () => speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultThree,
+  speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultTwo: () => speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultTwo,
+  speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefault: () => speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefault,
+  speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFive: () => speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFive,
+  speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFour: () => speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFour,
+  speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultOne: () => speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultOne,
+  speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultThree: () => speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultThree,
+  speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultTwo: () => speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultTwo,
+  speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefault: () => speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefault,
+  speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefaultThree: () => speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefaultThree,
+  speechToTextBodyAdditionalFormatsItemMaxSegmentCharsDefaultOnefive: () => speechToTextBodyAdditionalFormatsItemMaxSegmentCharsDefaultOnefive,
+  speechToTextBodyAdditionalFormatsItemMaxSegmentDurationSDefaultOnefive: () => speechToTextBodyAdditionalFormatsItemMaxSegmentDurationSDefaultOnefive,
+  speechToTextBodyAdditionalFormatsItemSegmentOnSilenceLongerThanSDefaultOnefive: () => speechToTextBodyAdditionalFormatsItemSegmentOnSilenceLongerThanSDefaultOnefive,
+  speechToTextBodyAdditionalFormatsMax: () => speechToTextBodyAdditionalFormatsMax,
+  speechToTextBodyDiarizationThresholdMaxOne: () => speechToTextBodyDiarizationThresholdMaxOne,
+  speechToTextBodyDiarizationThresholdMinOne: () => speechToTextBodyDiarizationThresholdMinOne,
+  speechToTextBodyDiarizeDefault: () => speechToTextBodyDiarizeDefault,
+  speechToTextBodyFileFormatDefault: () => speechToTextBodyFileFormatDefault,
+  speechToTextBodyKeytermsDefault: () => speechToTextBodyKeytermsDefault,
+  speechToTextBodyNoVerbatimDefault: () => speechToTextBodyNoVerbatimDefault,
+  speechToTextBodyNumSpeakersMaxOne: () => speechToTextBodyNumSpeakersMaxOne,
+  speechToTextBodySeedMaxOne: () => speechToTextBodySeedMaxOne,
+  speechToTextBodySeedMinOne: () => speechToTextBodySeedMinOne,
+  speechToTextBodyTagAudioEventsDefault: () => speechToTextBodyTagAudioEventsDefault,
+  speechToTextBodyTemperatureMaxOne: () => speechToTextBodyTemperatureMaxOne,
+  speechToTextBodyTemperatureMinOne: () => speechToTextBodyTemperatureMinOne,
+  speechToTextBodyTimestampsGranularityDefault: () => speechToTextBodyTimestampsGranularityDefault,
+  speechToTextBodyUseMultiChannelDefault: () => speechToTextBodyUseMultiChannelDefault,
+  speechToTextBodyWebhookDefault: () => speechToTextBodyWebhookDefault,
+  speechToTextHeader: () => speechToTextHeader,
+  speechToTextQueryEnableLoggingDefault: () => speechToTextQueryEnableLoggingDefault,
+  speechToTextQueryParams: () => speechToTextQueryParams,
+  speechToTextResponse: () => speechToTextResponse
+});
+var import_zod13 = require("zod");
+var speechToTextQueryEnableLoggingDefault = true;
+var speechToTextQueryParams = import_zod13.z.object({
+  enable_logging: import_zod13.z.boolean().default(speechToTextQueryEnableLoggingDefault).describe(
+    "When enable_logging is set to false zero retention mode will be used for the request. This will mean log and transcript storage features are unavailable for this request. Zero retention mode may only be used by enterprise customers."
+  )
+});
+var speechToTextHeader = import_zod13.z.object({
+  "xi-api-key": import_zod13.z.string().or(import_zod13.z.null()).optional().describe(
+    "Your API key. This is required by most endpoints to access our API programmatically. You can view your xi-api-key using the 'Profile' tab on the website."
+  )
+});
+var speechToTextBodyTagAudioEventsDefault = true;
+var speechToTextBodyNumSpeakersMaxOne = 32;
+var speechToTextBodyTimestampsGranularityDefault = "word";
+var speechToTextBodyDiarizeDefault = false;
+var speechToTextBodyDiarizationThresholdMinOne = 0.1;
+var speechToTextBodyDiarizationThresholdMaxOne = 0.4;
+var speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefault = true;
+var speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefault = true;
+var speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultOne = true;
+var speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultOne = true;
+var speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultTwo = true;
+var speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultTwo = true;
+var speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefault = 100;
+var speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultThree = true;
+var speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultThree = true;
+var speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultFour = true;
+var speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFour = true;
+var speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefaultThree = 42;
+var speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultFive = false;
+var speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFive = true;
+var speechToTextBodyAdditionalFormatsItemSegmentOnSilenceLongerThanSDefaultOnefive = 0.8;
+var speechToTextBodyAdditionalFormatsItemMaxSegmentDurationSDefaultOnefive = 4;
+var speechToTextBodyAdditionalFormatsItemMaxSegmentCharsDefaultOnefive = 84;
+var speechToTextBodyAdditionalFormatsMax = 10;
+var speechToTextBodyFileFormatDefault = "other";
+var speechToTextBodyWebhookDefault = false;
+var speechToTextBodyTemperatureMinOne = 0;
+var speechToTextBodyTemperatureMaxOne = 2;
+var speechToTextBodySeedMinOne = 0;
+var speechToTextBodySeedMaxOne = 2147483647;
+var speechToTextBodyUseMultiChannelDefault = false;
+var speechToTextBodyNoVerbatimDefault = false;
+var speechToTextBodyKeytermsDefault = [];
+var speechToTextBody = import_zod13.z.object({
+  model_id: import_zod13.z.enum(["scribe_v1", "scribe_v2"]).describe("The ID of the model to use for transcription."),
+  file: import_zod13.z.instanceof(File).or(import_zod13.z.null()).optional().describe(
+    "The file to transcribe. All major audio and video formats are supported. Exactly one of the file or cloud_storage_url parameters must be provided. The file size must be less than 3.0GB."
+  ),
+  language_code: import_zod13.z.string().or(import_zod13.z.null()).optional().describe(
+    "An ISO-639-1 or ISO-639-3 language_code corresponding to the language of the audio file. Can sometimes improve transcription performance if known beforehand. Defaults to null, in this case the language is predicted automatically."
+  ),
+  tag_audio_events: import_zod13.z.boolean().default(speechToTextBodyTagAudioEventsDefault).describe(
+    "Whether to tag audio events like (laughter), (footsteps), etc. in the transcription."
+  ),
+  num_speakers: import_zod13.z.number().min(1).max(speechToTextBodyNumSpeakersMaxOne).or(import_zod13.z.null()).optional().describe(
+    "The maximum amount of speakers talking in the uploaded file. Can help with predicting who speaks when. The maximum amount of speakers that can be predicted is 32. Defaults to null, in this case the amount of speakers is set to the maximum value the model supports."
+  ),
+  timestamps_granularity: import_zod13.z.enum(["none", "word", "character"]).default(speechToTextBodyTimestampsGranularityDefault).describe(
+    "The granularity of the timestamps in the transcription. 'word' provides word-level timestamps and 'character' provides character-level timestamps per word."
+  ),
+  diarize: import_zod13.z.boolean().optional().describe("Whether to annotate which speaker is currently talking in the uploaded file."),
+  diarization_threshold: import_zod13.z.number().min(speechToTextBodyDiarizationThresholdMinOne).max(speechToTextBodyDiarizationThresholdMaxOne).or(import_zod13.z.null()).optional().describe(
+    "Diarization threshold to apply during speaker diarization. A higher value means there will be a lower chance of one speaker being diarized as two different speakers but also a higher chance of two different speakers being diarized as one speaker (less total speakers predicted). A low value means there will be a higher chance of one speaker being diarized as two different speakers but also a lower chance of two different speakers being diarized as one speaker (more total speakers predicted). Can only be set when diarize=True and num_speakers=None. Defaults to None, in which case we will choose a threshold based on the model_id (0.22 usually)."
+  ),
+  additional_formats: import_zod13.z.array(
+    import_zod13.z.discriminatedUnion("format", [
+      import_zod13.z.object({
+        include_speakers: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefault),
+        include_timestamps: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefault),
+        format: import_zod13.z.enum(["segmented_json"]),
+        segment_on_silence_longer_than_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_duration_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_chars: import_zod13.z.number().or(import_zod13.z.null()).optional()
+      }),
+      import_zod13.z.object({
+        include_speakers: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultOne),
+        include_timestamps: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultOne),
+        format: import_zod13.z.enum(["docx"]),
+        segment_on_silence_longer_than_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_duration_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_chars: import_zod13.z.number().or(import_zod13.z.null()).optional()
+      }),
+      import_zod13.z.object({
+        include_speakers: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultTwo),
+        include_timestamps: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultTwo),
+        format: import_zod13.z.enum(["pdf"]),
+        segment_on_silence_longer_than_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_duration_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_chars: import_zod13.z.number().or(import_zod13.z.null()).optional()
+      }),
+      import_zod13.z.object({
+        max_characters_per_line: import_zod13.z.number().or(import_zod13.z.null()).default(speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefault),
+        include_speakers: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultThree),
+        include_timestamps: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultThree),
+        format: import_zod13.z.enum(["txt"]),
+        segment_on_silence_longer_than_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_duration_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_chars: import_zod13.z.number().or(import_zod13.z.null()).optional()
+      }),
+      import_zod13.z.object({
+        include_speakers: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeSpeakersDefaultFour),
+        include_timestamps: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFour),
+        format: import_zod13.z.enum(["html"]),
+        segment_on_silence_longer_than_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_duration_s: import_zod13.z.number().or(import_zod13.z.null()).optional(),
+        max_segment_chars: import_zod13.z.number().or(import_zod13.z.null()).optional()
+      }),
+      import_zod13.z.object({
+        max_characters_per_line: import_zod13.z.number().or(import_zod13.z.null()).default(speechToTextBodyAdditionalFormatsItemMaxCharactersPerLineDefaultThree),
+        include_speakers: import_zod13.z.boolean().optional(),
+        include_timestamps: import_zod13.z.boolean().default(speechToTextBodyAdditionalFormatsItemIncludeTimestampsDefaultFive),
+        format: import_zod13.z.enum(["srt"]),
+        segment_on_silence_longer_than_s: import_zod13.z.number().or(import_zod13.z.null()).default(
+          speechToTextBodyAdditionalFormatsItemSegmentOnSilenceLongerThanSDefaultOnefive
+        ),
+        max_segment_duration_s: import_zod13.z.number().or(import_zod13.z.null()).default(speechToTextBodyAdditionalFormatsItemMaxSegmentDurationSDefaultOnefive),
+        max_segment_chars: import_zod13.z.number().or(import_zod13.z.null()).default(speechToTextBodyAdditionalFormatsItemMaxSegmentCharsDefaultOnefive)
+      })
+    ])
+  ).max(speechToTextBodyAdditionalFormatsMax).optional(),
+  file_format: import_zod13.z.enum(["pcm_s16le_16", "other"]).default(speechToTextBodyFileFormatDefault).describe(
+    "The format of input audio. Options are 'pcm_s16le_16' or 'other' For `pcm_s16le_16`, the input audio must be 16-bit PCM at a 16kHz sample rate, single channel (mono), and little-endian byte order. Latency will be lower than with passing an encoded waveform."
+  ),
+  cloud_storage_url: import_zod13.z.string().or(import_zod13.z.null()).optional().describe(
+    "The HTTPS URL of the file to transcribe. Exactly one of the file or cloud_storage_url parameters must be provided. The file must be accessible via HTTPS and the file size must be less than 2GB. Any valid HTTPS URL is accepted, including URLs from cloud storage providers (AWS S3, Google Cloud Storage, Cloudflare R2, etc.), CDNs, or any other HTTPS source. URLs can be pre-signed or include authentication tokens in query parameters."
+  ),
+  webhook: import_zod13.z.boolean().optional().describe(
+    "Whether to send the transcription result to configured speech-to-text webhooks.  If set the request will return early without the transcription, which will be delivered later via webhook."
+  ),
+  webhook_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe(
+    "Optional specific webhook ID to send the transcription result to. Only valid when webhook is set to true. If not provided, transcription will be sent to all configured speech-to-text webhooks."
+  ),
+  temperature: import_zod13.z.number().min(speechToTextBodyTemperatureMinOne).max(speechToTextBodyTemperatureMaxOne).or(import_zod13.z.null()).optional().describe(
+    "Controls the randomness of the transcription output. Accepts values between 0.0 and 2.0, where higher values result in more diverse and less deterministic results. If omitted, we will use a temperature based on the model you selected which is usually 0."
+  ),
+  seed: import_zod13.z.number().min(speechToTextBodySeedMinOne).max(speechToTextBodySeedMaxOne).or(import_zod13.z.null()).optional().describe(
+    "If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result. Determinism is not guaranteed. Must be an integer between 0 and 2147483647."
+  ),
+  use_multi_channel: import_zod13.z.boolean().optional().describe(
+    "Whether the audio file contains multiple channels where each channel contains a single speaker. When enabled, each channel will be transcribed independently and the results will be combined. Each word in the response will include a 'channel_index' field indicating which channel it was spoken on. A maximum of 5 channels is supported."
+  ),
+  webhook_metadata: import_zod13.z.string().or(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any())).or(import_zod13.z.null()).optional().describe(
+    "Optional metadata to be included in the webhook response. This should be a JSON string representing an object with a maximum depth of 2 levels and maximum size of 16KB. Useful for tracking internal IDs, job references, or other contextual information."
+  ),
+  entity_detection: import_zod13.z.string().or(import_zod13.z.array(import_zod13.z.string())).or(import_zod13.z.null()).optional().describe(
+    "Detect entities in the transcript. Can be 'all' to detect all entities, a single entity type or category string, or a list of entity types/categories. Categories include 'pii', 'phi', 'pci', 'other', 'offensive_language'. When enabled, detected entities will be returned in the 'entities' field with their text, type, and character positions. Usage of this parameter will incur additional costs."
+  ),
+  no_verbatim: import_zod13.z.boolean().optional().describe(
+    "If true, the transcription will not have any filler words, false starts and non-speech sounds. Only supported with scribe_v2 model."
+  ),
+  keyterms: import_zod13.z.array(import_zod13.z.string()).default(speechToTextBodyKeytermsDefault).describe(
+    'A list of keyterms to bias the transcription towards.           The keyterms are words or phrases you want the model to recognise more accurately.           The number of keyterms cannot exceed 100.           The length of each keyterm must be less than 50 characters.           Keyterms can contain at most 5 words (after normalisation).           For example ["hello", "world", "technical term"].           Usage of this parameter will incur additional costs.  '
+  )
+});
+var speechToTextResponse = import_zod13.z.object({
+  language_code: import_zod13.z.string().describe("The detected language code (e.g. 'eng' for English)."),
+  language_probability: import_zod13.z.number().describe("The confidence score of the language detection (0 to 1)."),
+  text: import_zod13.z.string().describe("The raw text of the transcription."),
+  words: import_zod13.z.array(
+    import_zod13.z.object({
+      text: import_zod13.z.string().describe("The word or sound that was transcribed."),
+      start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the word or sound in seconds."),
+      end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the word or sound in seconds."),
+      type: import_zod13.z.enum(["word", "spacing", "audio_event"]).describe(
+        "The type of the word or sound. 'audio_event' is used for non-word sounds like laughter or footsteps."
+      ),
+      speaker_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("Unique identifier for the speaker of this word."),
+      logprob: import_zod13.z.number().describe(
+        "The log of the probability with which this word was predicted. Logprobs are in range [-infinity, 0], higher logprobs indicate a higher confidence the model has in its predictions."
+      ),
+      characters: import_zod13.z.array(
+        import_zod13.z.object({
+          text: import_zod13.z.string().describe("The character that was transcribed."),
+          start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the character in seconds."),
+          end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the character in seconds.")
+        })
+      ).or(import_zod13.z.null()).optional().describe("The characters that make up the word and their timing information.")
+    }).describe("Word-level detail of the transcription with timing information.")
+  ).describe("List of words with their timing information."),
+  channel_index: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The channel index this transcript belongs to (for multichannel audio)."),
+  additional_formats: import_zod13.z.array(
+    import_zod13.z.object({
+      requested_format: import_zod13.z.string().describe("The requested format."),
+      file_extension: import_zod13.z.string().describe("The file extension of the additional format."),
+      content_type: import_zod13.z.string().describe("The content type of the additional format."),
+      is_base64_encoded: import_zod13.z.boolean().describe("Whether the content is base64 encoded."),
+      content: import_zod13.z.string().describe("The content of the additional format.")
+    }).or(import_zod13.z.null())
+  ).or(import_zod13.z.null()).optional().describe("Requested additional formats of the transcript."),
+  transcription_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("The transcription ID of the response."),
+  entities: import_zod13.z.array(
+    import_zod13.z.object({
+      text: import_zod13.z.string().describe("The text that was identified as an entity."),
+      entity_type: import_zod13.z.string().describe(
+        "The type of entity detected (e.g., 'credit_card', 'email_address', 'person_name')."
+      ),
+      start_char: import_zod13.z.number().describe("Start character position in the transcript text."),
+      end_char: import_zod13.z.number().describe("End character position in the transcript text.")
+    })
+  ).or(import_zod13.z.null()).optional().describe(
+    "List of detected entities with their text, type, and character positions in the transcript."
+  )
+}).describe("Chunk-level detail of the transcription with timing information.").or(
+  import_zod13.z.object({
+    transcripts: import_zod13.z.array(
+      import_zod13.z.object({
+        language_code: import_zod13.z.string().describe("The detected language code (e.g. 'eng' for English)."),
+        language_probability: import_zod13.z.number().describe("The confidence score of the language detection (0 to 1)."),
+        text: import_zod13.z.string().describe("The raw text of the transcription."),
+        words: import_zod13.z.array(
+          import_zod13.z.object({
+            text: import_zod13.z.string().describe("The word or sound that was transcribed."),
+            start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the word or sound in seconds."),
+            end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the word or sound in seconds."),
+            type: import_zod13.z.enum(["word", "spacing", "audio_event"]).describe(
+              "The type of the word or sound. 'audio_event' is used for non-word sounds like laughter or footsteps."
+            ),
+            speaker_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("Unique identifier for the speaker of this word."),
+            logprob: import_zod13.z.number().describe(
+              "The log of the probability with which this word was predicted. Logprobs are in range [-infinity, 0], higher logprobs indicate a higher confidence the model has in its predictions."
+            ),
+            characters: import_zod13.z.array(
+              import_zod13.z.object({
+                text: import_zod13.z.string().describe("The character that was transcribed."),
+                start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the character in seconds."),
+                end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the character in seconds.")
+              })
+            ).or(import_zod13.z.null()).optional().describe(
+              "The characters that make up the word and their timing information."
+            )
+          }).describe("Word-level detail of the transcription with timing information.")
+        ).describe("List of words with their timing information."),
+        channel_index: import_zod13.z.number().or(import_zod13.z.null()).optional().describe(
+          "The channel index this transcript belongs to (for multichannel audio)."
+        ),
+        additional_formats: import_zod13.z.array(
+          import_zod13.z.object({
+            requested_format: import_zod13.z.string().describe("The requested format."),
+            file_extension: import_zod13.z.string().describe("The file extension of the additional format."),
+            content_type: import_zod13.z.string().describe("The content type of the additional format."),
+            is_base64_encoded: import_zod13.z.boolean().describe("Whether the content is base64 encoded."),
+            content: import_zod13.z.string().describe("The content of the additional format.")
+          }).or(import_zod13.z.null())
+        ).or(import_zod13.z.null()).optional().describe("Requested additional formats of the transcript."),
+        transcription_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("The transcription ID of the response."),
+        entities: import_zod13.z.array(
+          import_zod13.z.object({
+            text: import_zod13.z.string().describe("The text that was identified as an entity."),
+            entity_type: import_zod13.z.string().describe(
+              "The type of entity detected (e.g., 'credit_card', 'email_address', 'person_name')."
+            ),
+            start_char: import_zod13.z.number().describe("Start character position in the transcript text."),
+            end_char: import_zod13.z.number().describe("End character position in the transcript text.")
+          })
+        ).or(import_zod13.z.null()).optional().describe(
+          "List of detected entities with their text, type, and character positions in the transcript."
+        )
+      }).describe("Chunk-level detail of the transcription with timing information.")
+    ).describe(
+      "List of transcripts, one for each audio channel. Each transcript contains the text and word-level details for its respective channel."
+    ),
+    transcription_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("The transcription ID of the response.")
+  }).describe("Response model for multichannel speech-to-text transcription.")
+);
+var getTranscriptByIdParams = import_zod13.z.object({
+  transcription_id: import_zod13.z.string().describe("The unique ID of the transcript to retrieve")
+});
+var getTranscriptByIdHeader = import_zod13.z.object({
+  "xi-api-key": import_zod13.z.string().or(import_zod13.z.null()).optional().describe(
+    "Your API key. This is required by most endpoints to access our API programmatically. You can view your xi-api-key using the 'Profile' tab on the website."
+  )
+});
+var getTranscriptByIdResponse = import_zod13.z.object({
+  language_code: import_zod13.z.string().describe("The detected language code (e.g. 'eng' for English)."),
+  language_probability: import_zod13.z.number().describe("The confidence score of the language detection (0 to 1)."),
+  text: import_zod13.z.string().describe("The raw text of the transcription."),
+  words: import_zod13.z.array(
+    import_zod13.z.object({
+      text: import_zod13.z.string().describe("The word or sound that was transcribed."),
+      start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the word or sound in seconds."),
+      end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the word or sound in seconds."),
+      type: import_zod13.z.enum(["word", "spacing", "audio_event"]).describe(
+        "The type of the word or sound. 'audio_event' is used for non-word sounds like laughter or footsteps."
+      ),
+      speaker_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("Unique identifier for the speaker of this word."),
+      logprob: import_zod13.z.number().describe(
+        "The log of the probability with which this word was predicted. Logprobs are in range [-infinity, 0], higher logprobs indicate a higher confidence the model has in its predictions."
+      ),
+      characters: import_zod13.z.array(
+        import_zod13.z.object({
+          text: import_zod13.z.string().describe("The character that was transcribed."),
+          start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the character in seconds."),
+          end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the character in seconds.")
+        })
+      ).or(import_zod13.z.null()).optional().describe("The characters that make up the word and their timing information.")
+    }).describe("Word-level detail of the transcription with timing information.")
+  ).describe("List of words with their timing information."),
+  channel_index: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The channel index this transcript belongs to (for multichannel audio)."),
+  additional_formats: import_zod13.z.array(
+    import_zod13.z.object({
+      requested_format: import_zod13.z.string().describe("The requested format."),
+      file_extension: import_zod13.z.string().describe("The file extension of the additional format."),
+      content_type: import_zod13.z.string().describe("The content type of the additional format."),
+      is_base64_encoded: import_zod13.z.boolean().describe("Whether the content is base64 encoded."),
+      content: import_zod13.z.string().describe("The content of the additional format.")
+    }).or(import_zod13.z.null())
+  ).or(import_zod13.z.null()).optional().describe("Requested additional formats of the transcript."),
+  transcription_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("The transcription ID of the response."),
+  entities: import_zod13.z.array(
+    import_zod13.z.object({
+      text: import_zod13.z.string().describe("The text that was identified as an entity."),
+      entity_type: import_zod13.z.string().describe(
+        "The type of entity detected (e.g., 'credit_card', 'email_address', 'person_name')."
+      ),
+      start_char: import_zod13.z.number().describe("Start character position in the transcript text."),
+      end_char: import_zod13.z.number().describe("End character position in the transcript text.")
+    })
+  ).or(import_zod13.z.null()).optional().describe(
+    "List of detected entities with their text, type, and character positions in the transcript."
+  )
+}).describe("Chunk-level detail of the transcription with timing information.").or(
+  import_zod13.z.object({
+    transcripts: import_zod13.z.array(
+      import_zod13.z.object({
+        language_code: import_zod13.z.string().describe("The detected language code (e.g. 'eng' for English)."),
+        language_probability: import_zod13.z.number().describe("The confidence score of the language detection (0 to 1)."),
+        text: import_zod13.z.string().describe("The raw text of the transcription."),
+        words: import_zod13.z.array(
+          import_zod13.z.object({
+            text: import_zod13.z.string().describe("The word or sound that was transcribed."),
+            start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the word or sound in seconds."),
+            end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the word or sound in seconds."),
+            type: import_zod13.z.enum(["word", "spacing", "audio_event"]).describe(
+              "The type of the word or sound. 'audio_event' is used for non-word sounds like laughter or footsteps."
+            ),
+            speaker_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("Unique identifier for the speaker of this word."),
+            logprob: import_zod13.z.number().describe(
+              "The log of the probability with which this word was predicted. Logprobs are in range [-infinity, 0], higher logprobs indicate a higher confidence the model has in its predictions."
+            ),
+            characters: import_zod13.z.array(
+              import_zod13.z.object({
+                text: import_zod13.z.string().describe("The character that was transcribed."),
+                start: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The start time of the character in seconds."),
+                end: import_zod13.z.number().or(import_zod13.z.null()).optional().describe("The end time of the character in seconds.")
+              })
+            ).or(import_zod13.z.null()).optional().describe(
+              "The characters that make up the word and their timing information."
+            )
+          }).describe("Word-level detail of the transcription with timing information.")
+        ).describe("List of words with their timing information."),
+        channel_index: import_zod13.z.number().or(import_zod13.z.null()).optional().describe(
+          "The channel index this transcript belongs to (for multichannel audio)."
+        ),
+        additional_formats: import_zod13.z.array(
+          import_zod13.z.object({
+            requested_format: import_zod13.z.string().describe("The requested format."),
+            file_extension: import_zod13.z.string().describe("The file extension of the additional format."),
+            content_type: import_zod13.z.string().describe("The content type of the additional format."),
+            is_base64_encoded: import_zod13.z.boolean().describe("Whether the content is base64 encoded."),
+            content: import_zod13.z.string().describe("The content of the additional format.")
+          }).or(import_zod13.z.null())
+        ).or(import_zod13.z.null()).optional().describe("Requested additional formats of the transcript."),
+        transcription_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("The transcription ID of the response."),
+        entities: import_zod13.z.array(
+          import_zod13.z.object({
+            text: import_zod13.z.string().describe("The text that was identified as an entity."),
+            entity_type: import_zod13.z.string().describe(
+              "The type of entity detected (e.g., 'credit_card', 'email_address', 'person_name')."
+            ),
+            start_char: import_zod13.z.number().describe("Start character position in the transcript text."),
+            end_char: import_zod13.z.number().describe("End character position in the transcript text.")
+          })
+        ).or(import_zod13.z.null()).optional().describe(
+          "List of detected entities with their text, type, and character positions in the transcript."
+        )
+      }).describe("Chunk-level detail of the transcription with timing information.")
+    ).describe(
+      "List of transcripts, one for each audio channel. Each transcript contains the text and word-level details for its respective channel."
+    ),
+    transcription_id: import_zod13.z.string().or(import_zod13.z.null()).optional().describe("The transcription ID of the response.")
+  }).describe("Response model for multichannel speech-to-text transcription.")
+);
+var deleteTranscriptByIdParams = import_zod13.z.object({
+  transcription_id: import_zod13.z.string().describe("The unique ID of the transcript to delete")
+});
+var deleteTranscriptByIdHeader = import_zod13.z.object({
+  "xi-api-key": import_zod13.z.string().or(import_zod13.z.null()).optional().describe(
+    "Your API key. This is required by most endpoints to access our API programmatically. You can view your xi-api-key using the 'Profile' tab on the website."
+  )
+});
+var deleteTranscriptByIdResponse = import_zod13.z.any();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AllLanguageCodes,
@@ -38762,6 +40129,13 @@ var getUsageResponse = import_zod12.z.object({
   DeepgramTranscriptionSchema,
   DeepgramTypes,
   DeepgramZodSchemas,
+  ElevenLabsAdapter,
+  ElevenLabsCapabilities,
+  ElevenLabsLanguageCodes,
+  ElevenLabsLanguageLabels,
+  ElevenLabsLanguages,
+  ElevenLabsTypes,
+  ElevenLabsZodSchemas,
   GladiaAdapter,
   GladiaBitDepth,
   GladiaCapabilities,
@@ -38848,6 +40222,7 @@ var getUsageResponse = import_zod12.z.object({
   createAssemblyAIAdapter,
   createAzureSTTAdapter,
   createDeepgramAdapter,
+  createElevenLabsAdapter,
   createGladiaAdapter,
   createOpenAIWhisperAdapter,
   createSonioxAdapter,