voice-router-dev 0.1.0

package/dist/index.js

@@ -0,0 +1,4880 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AssemblyAIAdapter: () => AssemblyAIAdapter,
+  AssemblyAITypes: () => schema_exports2,
+  AssemblyAIWebhookHandler: () => AssemblyAIWebhookHandler,
+  AzureSTTAdapter: () => AzureSTTAdapter,
+  AzureWebhookHandler: () => AzureWebhookHandler,
+  BaseAdapter: () => BaseAdapter,
+  BaseWebhookHandler: () => BaseWebhookHandler,
+  DeepgramAdapter: () => DeepgramAdapter,
+  DeepgramWebhookHandler: () => DeepgramWebhookHandler,
+  GladiaAdapter: () => GladiaAdapter,
+  GladiaTypes: () => schema_exports,
+  GladiaWebhookHandler: () => GladiaWebhookHandler,
+  OpenAIWhisperAdapter: () => OpenAIWhisperAdapter,
+  SpeechmaticsAdapter: () => SpeechmaticsAdapter,
+  SpeechmaticsWebhookHandler: () => SpeechmaticsWebhookHandler,
+  VoiceRouter: () => VoiceRouter,
+  WebhookRouter: () => WebhookRouter,
+  createAssemblyAIAdapter: () => createAssemblyAIAdapter,
+  createAssemblyAIWebhookHandler: () => createAssemblyAIWebhookHandler,
+  createAzureSTTAdapter: () => createAzureSTTAdapter,
+  createAzureWebhookHandler: () => createAzureWebhookHandler,
+  createDeepgramAdapter: () => createDeepgramAdapter,
+  createDeepgramWebhookHandler: () => createDeepgramWebhookHandler,
+  createGladiaAdapter: () => createGladiaAdapter,
+  createGladiaWebhookHandler: () => createGladiaWebhookHandler,
+  createOpenAIWhisperAdapter: () => createOpenAIWhisperAdapter,
+  createSpeechmaticsAdapter: () => createSpeechmaticsAdapter,
+  createVoiceRouter: () => createVoiceRouter,
+  createWebhookRouter: () => createWebhookRouter
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/router/voice-router.ts
+var VoiceRouter = class {
+  constructor(config) {
+    this.adapters = /* @__PURE__ */ new Map();
+    this.roundRobinIndex = 0;
+    this.config = {
+      selectionStrategy: "default",
+      ...config
+    };
+    if (Object.keys(config.providers).length === 0) {
+      throw new Error("VoiceRouter requires at least one provider configuration");
+    }
+    if (this.config.selectionStrategy === "default" && !this.config.defaultProvider) {
+      this.config.defaultProvider = Object.keys(config.providers)[0];
+    }
+  }
+  /**
+   * Register an adapter for a provider
+   *
+   * Call this method for each provider you want to use. The adapter will be
+   * initialized with the configuration provided in the constructor.
+   *
+   * @param adapter - Provider adapter instance to register
+   * @throws {Error} If no configuration found for the provider
+   *
+   * @example
+   * ```typescript
+   * const router = new VoiceRouter({
+   *   providers: {
+   *     gladia: { apiKey: 'YOUR_KEY' }
+   *   }
+   * });
+   *
+   * router.registerAdapter(new GladiaAdapter());
+   * ```
+   */
+  registerAdapter(adapter) {
+    const providerConfig = this.config.providers[adapter.name];
+    if (!providerConfig) {
+      throw new Error(`No configuration found for provider: ${adapter.name}`);
+    }
+    adapter.initialize(providerConfig);
+    this.adapters.set(adapter.name, adapter);
+  }
+  /**
+   * Get an adapter by provider name
+   */
+  getAdapter(provider) {
+    const adapter = this.adapters.get(provider);
+    if (!adapter) {
+      throw new Error(
+        `Provider '${provider}' is not registered. Available providers: ${Array.from(this.adapters.keys()).join(", ")}`
+      );
+    }
+    return adapter;
+  }
+  /**
+   * Select provider based on configured strategy
+   */
+  selectProvider(preferredProvider) {
+    if (preferredProvider) {
+      if (!this.adapters.has(preferredProvider)) {
+        throw new Error(
+          `Provider '${preferredProvider}' is not registered. Available providers: ${Array.from(this.adapters.keys()).join(", ")}`
+        );
+      }
+      return preferredProvider;
+    }
+    switch (this.config.selectionStrategy) {
+      case "explicit":
+        throw new Error(
+          "Provider must be explicitly specified when using 'explicit' selection strategy"
+        );
+      case "round-robin": {
+        const providers = Array.from(this.adapters.keys());
+        const provider = providers[this.roundRobinIndex % providers.length];
+        this.roundRobinIndex++;
+        return provider;
+      }
+      case "default":
+      default:
+        if (!this.config.defaultProvider) {
+          throw new Error("No default provider configured");
+        }
+        return this.config.defaultProvider;
+    }
+  }
+  /**
+   * Transcribe audio using a specific provider or the default
+   *
+   * Submit audio for transcription. The provider will be selected based on
+   * your configuration strategy (explicit, default, or round-robin).
+   *
+   * @param audio - Audio input (URL, file buffer, or stream)
+   * @param options - Transcription options (language, diarization, etc.)
+   * @param options.provider - Specific provider to use (overrides selection strategy)
+   * @returns Unified transcription response with normalized format
+   * @throws {Error} If provider not registered or selection fails
+   *
+   * @example URL audio
+   * ```typescript
+   * const result = await router.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/audio.mp3'
+   * }, {
+   *   language: 'en',
+   *   diarization: true,
+   *   summarization: true
+   * });
+   *
+   * if (result.success) {
+   *   console.log('Transcript:', result.data.text);
+   *   console.log('Speakers:', result.data.speakers);
+   *   console.log('Summary:', result.data.summary);
+   * }
+   * ```
+   *
+   * @example Specific provider
+   * ```typescript
+   * const result = await router.transcribe(audio, {
+   *   provider: 'gladia',  // Force use of Gladia
+   *   language: 'en'
+   * });
+   * ```
+   */
+  async transcribe(audio, options) {
+    const provider = this.selectProvider(options?.provider);
+    const adapter = this.getAdapter(provider);
+    const { provider: _, ...adapterOptions } = options || {};
+    return adapter.transcribe(audio, adapterOptions);
+  }
+  /**
+   * Get transcription result by ID
+   * Provider must be specified since IDs are provider-specific
+   */
+  async getTranscript(transcriptId, provider) {
+    const adapter = this.getAdapter(provider);
+    return adapter.getTranscript(transcriptId);
+  }
+  /**
+   * Stream audio for real-time transcription
+   * Only works with providers that support streaming
+   *
+   * @param options - Streaming options including provider selection
+   * @param callbacks - Event callbacks for transcription results
+   * @returns Promise that resolves with a StreamingSession
+   *
+   * @example
+   * ```typescript
+   * import { VoiceRouter } from '@meeting-baas/sdk';
+   *
+   * const router = new VoiceRouter();
+   * router.initialize({
+   *   gladia: { apiKey: process.env.GLADIA_KEY },
+   *   deepgram: { apiKey: process.env.DEEPGRAM_KEY }
+   * });
+   *
+   * const session = await router.transcribeStream({
+   *   provider: 'deepgram',
+   *   encoding: 'linear16',
+   *   sampleRate: 16000,
+   *   language: 'en'
+   * }, {
+   *   onTranscript: (event) => console.log(event.text),
+   *   onError: (error) => console.error(error)
+   * });
+   *
+   * // Send audio chunks
+   * await session.sendAudio({ data: audioBuffer });
+   * await session.close();
+   * ```
+   */
+  async transcribeStream(options, callbacks) {
+    const provider = this.selectProvider(options?.provider);
+    const adapter = this.getAdapter(provider);
+    if (!adapter.capabilities.streaming || !adapter.transcribeStream) {
+      throw new Error(`Provider '${provider}' does not support streaming transcription`);
+    }
+    const { provider: _, ...adapterOptions } = options || {};
+    return adapter.transcribeStream(adapterOptions, callbacks);
+  }
+  /**
+   * Delete a transcription
+   * Not all providers support this operation
+   */
+  async deleteTranscript(transcriptId, provider) {
+    const adapter = this.getAdapter(provider);
+    if (!adapter.deleteTranscript) {
+      throw new Error(`Provider '${provider}' does not support deleting transcripts`);
+    }
+    return adapter.deleteTranscript(transcriptId);
+  }
+  /**
+   * List recent transcriptions
+   * Not all providers support this operation
+   */
+  async listTranscripts(provider, options) {
+    const adapter = this.getAdapter(provider);
+    if (!adapter.listTranscripts) {
+      throw new Error(`Provider '${provider}' does not support listing transcripts`);
+    }
+    return adapter.listTranscripts(options);
+  }
+  /**
+   * Get capabilities for a specific provider
+   */
+  getProviderCapabilities(provider) {
+    const adapter = this.getAdapter(provider);
+    return adapter.capabilities;
+  }
+  /**
+   * Get all registered providers
+   */
+  getRegisteredProviders() {
+    return Array.from(this.adapters.keys());
+  }
+  /**
+   * Get raw provider client for advanced usage
+   */
+  getRawProviderClient(provider) {
+    const adapter = this.getAdapter(provider);
+    if (!adapter.getRawClient) {
+      throw new Error(`Provider '${provider}' does not expose a raw client`);
+    }
+    return adapter.getRawClient();
+  }
+};
+function createVoiceRouter(config, adapters) {
+  const router = new VoiceRouter(config);
+  if (adapters && adapters.length > 0) {
+    for (const adapter of adapters) {
+      router.registerAdapter(adapter);
+    }
+  }
+  return router;
+}
+
+// src/adapters/base-adapter.ts
+var BaseAdapter = class {
+  initialize(config) {
+    this.config = config;
+  }
+  /**
+   * Helper method to create error responses
+   */
+  createErrorResponse(error, statusCode) {
+    const err = error;
+    return {
+      success: false,
+      provider: this.name,
+      error: {
+        code: err.code || "UNKNOWN_ERROR",
+        message: err.message || "An unknown error occurred",
+        statusCode: statusCode || err.statusCode,
+        details: error
+      }
+    };
+  }
+  /**
+   * Helper method to validate configuration
+   */
+  validateConfig() {
+    if (!this.config) {
+      throw new Error(`Adapter ${this.name} is not initialized. Call initialize() first.`);
+    }
+    if (!this.config.apiKey) {
+      throw new Error(`API key is required for ${this.name} provider`);
+    }
+  }
+};
+
+// src/adapters/gladia-adapter.ts
+var import_axios = __toESM(require("axios"));
+var import_ws = __toESM(require("ws"));
+var GladiaAdapter = class extends BaseAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "gladia";
+    this.capabilities = {
+      streaming: true,
+      diarization: true,
+      wordTimestamps: true,
+      languageDetection: true,
+      customVocabulary: true,
+      summarization: true,
+      sentimentAnalysis: true,
+      entityDetection: true,
+      piiRedaction: false
+      // Gladia doesn't have PII redaction in their API
+    };
+    this.baseUrl = "https://api.gladia.io/v2";
+  }
+  initialize(config) {
+    super.initialize(config);
+    this.client = import_axios.default.create({
+      baseURL: config.baseUrl || this.baseUrl,
+      timeout: config.timeout || 6e4,
+      headers: {
+        "x-gladia-key": config.apiKey,
+        "Content-Type": "application/json",
+        ...config.headers
+      }
+    });
+  }
+  /**
+   * Submit audio for transcription
+   *
+   * Sends audio to Gladia API for transcription. If a webhook URL is provided,
+   * returns immediately with the job ID. Otherwise, polls until completion.
+   *
+   * @param audio - Audio input (currently only URL type supported)
+   * @param options - Transcription options
+   * @param options.language - Language code (e.g., 'en', 'es', 'fr')
+   * @param options.languageDetection - Enable automatic language detection
+   * @param options.diarization - Enable speaker identification
+   * @param options.speakersExpected - Number of expected speakers (for diarization)
+   * @param options.summarization - Generate text summary
+   * @param options.sentimentAnalysis - Analyze sentiment of transcription
+   * @param options.customVocabulary - Words to boost in recognition
+   * @param options.webhookUrl - Callback URL for async results
+   * @returns Normalized transcription response
+   * @throws {Error} If audio type is not 'url' (file/stream not yet supported)
+   *
+   * @example Simple transcription
+   * ```typescript
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * });
+   * ```
+   *
+   * @example With advanced features
+   * ```typescript
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * }, {
+   *   language: 'en',
+   *   diarization: true,
+   *   speakersExpected: 3,
+   *   summarization: true,
+   *   customVocabulary: ['API', 'TypeScript', 'JavaScript']
+   * });
+   * ```
+   *
+   * @example With webhook (returns job ID immediately for polling)
+   * ```typescript
+   * // Submit transcription with webhook
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * }, {
+   *   webhookUrl: 'https://myapp.com/webhook/transcription',
+   *   language: 'en'
+   * });
+   *
+   * // Get job ID for polling
+   * const jobId = result.data?.id;
+   * console.log('Job ID:', jobId); // Use this to poll for status
+   *
+   * // Later: Poll for completion (if webhook fails or you want to check)
+   * const status = await adapter.getTranscript(jobId);
+   * if (status.data?.status === 'completed') {
+   *   console.log('Transcript:', status.data.text);
+   * }
+   * ```
+   */
+  async transcribe(audio, options) {
+    this.validateConfig();
+    try {
+      const payload = this.buildTranscriptionRequest(audio, options);
+      const response = await this.client.post(
+        "/transcription",
+        payload
+      );
+      const jobId = response.data.id;
+      if (options?.webhookUrl) {
+        return {
+          success: true,
+          provider: this.name,
+          data: {
+            id: jobId,
+            text: "",
+            status: "queued"
+          },
+          raw: response.data
+        };
+      }
+      return await this.pollForCompletion(jobId);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Get transcription result by ID
+   */
+  async getTranscript(transcriptId) {
+    this.validateConfig();
+    try {
+      const response = await this.client.get(`/transcription/${transcriptId}`);
+      return this.normalizeResponse(response.data);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Build Gladia transcription request from unified options
+   */
+  buildTranscriptionRequest(audio, options) {
+    let audioUrl;
+    if (audio.type === "url") {
+      audioUrl = audio.url;
+    } else {
+      throw new Error(
+        "Gladia adapter currently only supports URL-based audio input. Use audio.type='url'"
+      );
+    }
+    const request = {
+      audio_url: audioUrl
+    };
+    if (options) {
+      if (options.language || options.languageDetection) {
+        request.language_config = {
+          languages: options.language ? [options.language] : void 0,
+          code_switching: options.languageDetection
+        };
+      }
+      if (options.diarization) {
+        request.diarization = true;
+        if (options.speakersExpected) {
+          request.diarization_config = {
+            number_of_speakers: options.speakersExpected
+          };
+        }
+      }
+      if (options.customVocabulary && options.customVocabulary.length > 0) {
+        request.custom_vocabulary = true;
+        request.custom_vocabulary_config = {
+          vocabulary: options.customVocabulary
+        };
+      }
+      if (options.summarization) {
+        request.summarization = true;
+      }
+      if (options.sentimentAnalysis) {
+        request.sentiment_analysis = true;
+      }
+      if (options.entityDetection) {
+        request.named_entity_recognition = true;
+      }
+      if (options.webhookUrl) {
+        request.callback = true;
+        request.callback_config = {
+          url: options.webhookUrl
+        };
+      }
+      if (options.metadata) {
+        request.custom_metadata = options.metadata;
+      }
+    }
+    return request;
+  }
+  /**
+   * Normalize Gladia response to unified format
+   */
+  normalizeResponse(response) {
+    let status;
+    switch (response.status) {
+      case "queued":
+        status = "queued";
+        break;
+      case "processing":
+        status = "processing";
+        break;
+      case "done":
+        status = "completed";
+        break;
+      case "error":
+        status = "error";
+        break;
+      default:
+        status = "queued";
+    }
+    if (response.status === "error") {
+      return {
+        success: false,
+        provider: this.name,
+        error: {
+          code: response.error_code?.toString() || "TRANSCRIPTION_ERROR",
+          message: "Transcription failed",
+          statusCode: response.error_code || void 0
+        },
+        raw: response
+      };
+    }
+    const result = response.result;
+    const transcription = result?.transcription;
+    return {
+      success: true,
+      provider: this.name,
+      data: {
+        id: response.id,
+        text: transcription?.full_transcript || "",
+        confidence: void 0,
+        // Gladia doesn't provide overall confidence
+        status,
+        language: transcription?.languages?.[0],
+        // Use first detected language
+        duration: void 0,
+        // Not directly available in Gladia response
+        speakers: this.extractSpeakers(transcription),
+        words: this.extractWords(transcription),
+        utterances: this.extractUtterances(transcription),
+        summary: result?.summarization?.results || void 0,
+        metadata: {
+          requestParams: response.request_params,
+          customMetadata: response.custom_metadata
+        },
+        createdAt: response.created_at,
+        completedAt: response.completed_at || void 0
+      },
+      raw: response
+    };
+  }
+  /**
+   * Extract speaker information from Gladia response
+   */
+  extractSpeakers(transcription) {
+    if (!transcription?.utterances) {
+      return void 0;
+    }
+    const speakerSet = /* @__PURE__ */ new Set();
+    transcription.utterances.forEach((utterance) => {
+      if (utterance.speaker !== void 0) {
+        speakerSet.add(utterance.speaker);
+      }
+    });
+    if (speakerSet.size === 0) {
+      return void 0;
+    }
+    return Array.from(speakerSet).map((speakerId) => ({
+      id: speakerId.toString(),
+      label: `Speaker ${speakerId}`
+    }));
+  }
+  /**
+   * Extract word timestamps from Gladia response
+   */
+  extractWords(transcription) {
+    if (!transcription?.utterances) {
+      return void 0;
+    }
+    const allWords = transcription.utterances.flatMap(
+      (utterance) => utterance.words.map((word) => ({
+        text: word.word,
+        start: word.start,
+        end: word.end,
+        confidence: word.confidence,
+        speaker: utterance.speaker?.toString()
+      }))
+    );
+    return allWords.length > 0 ? allWords : void 0;
+  }
+  /**
+   * Extract utterances from Gladia response
+   */
+  extractUtterances(transcription) {
+    if (!transcription?.utterances) {
+      return void 0;
+    }
+    return transcription.utterances.map((utterance) => ({
+      text: utterance.text,
+      start: utterance.start,
+      end: utterance.end,
+      speaker: utterance.speaker?.toString(),
+      confidence: utterance.confidence,
+      words: utterance.words.map((word) => ({
+        text: word.word,
+        start: word.start,
+        end: word.end,
+        confidence: word.confidence
+      }))
+    }));
+  }
+  /**
+   * Poll for transcription completion
+   */
+  async pollForCompletion(jobId, maxAttempts = 60, intervalMs = 2e3) {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.getTranscript(jobId);
+      if (!result.success) {
+        return result;
+      }
+      const status = result.data?.status;
+      if (status === "completed") {
+        return result;
+      }
+      if (status === "error") {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "TRANSCRIPTION_ERROR",
+            message: "Transcription failed"
+          },
+          raw: result.raw
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return {
+      success: false,
+      provider: this.name,
+      error: {
+        code: "POLLING_TIMEOUT",
+        message: `Transcription did not complete after ${maxAttempts} attempts`
+      }
+    };
+  }
+  /**
+   * Stream audio for real-time transcription
+   *
+   * Creates a WebSocket connection to Gladia for streaming transcription.
+   * First initializes a session via REST API, then connects to WebSocket.
+   *
+   * @param options - Streaming configuration options
+   * @param callbacks - Event callbacks for transcription results
+   * @returns Promise that resolves with a StreamingSession
+   *
+   * @example Real-time streaming
+   * ```typescript
+   * const session = await adapter.transcribeStream({
+   *   encoding: 'wav/pcm',
+   *   sampleRate: 16000,
+   *   channels: 1,
+   *   language: 'en',
+   *   interimResults: true
+   * }, {
+   *   onOpen: () => console.log('Connected'),
+   *   onTranscript: (event) => {
+   *     if (event.isFinal) {
+   *       console.log('Final:', event.text);
+   *     } else {
+   *       console.log('Interim:', event.text);
+   *     }
+   *   },
+   *   onError: (error) => console.error('Error:', error),
+   *   onClose: () => console.log('Disconnected')
+   * });
+   *
+   * // Send audio chunks
+   * const audioChunk = getAudioChunk(); // Your audio source
+   * await session.sendAudio({ data: audioChunk });
+   *
+   * // Close when done
+   * await session.close();
+   * ```
+   */
+  async transcribeStream(options, callbacks) {
+    this.validateConfig();
+    const streamingRequest = {
+      encoding: options?.encoding,
+      sample_rate: options?.sampleRate,
+      channels: options?.channels,
+      endpointing: options?.endpointing
+    };
+    if (options?.language) {
+      streamingRequest.language_config = {
+        languages: [options.language]
+      };
+    }
+    const initResponse = await this.client.post(
+      "/streaming/init",
+      streamingRequest
+    );
+    const { id, url: wsUrl } = initResponse.data;
+    const ws = new import_ws.default(wsUrl);
+    let sessionStatus = "connecting";
+    ws.on("open", () => {
+      sessionStatus = "open";
+      callbacks?.onOpen?.();
+    });
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.type === "transcript") {
+          callbacks?.onTranscript?.({
+            type: "transcript",
+            text: message.text || "",
+            isFinal: message.is_final === true,
+            confidence: message.confidence,
+            words: message.words?.map((word) => ({
+              text: word.word || word.text,
+              start: word.start,
+              end: word.end,
+              confidence: word.confidence
+            })),
+            data: message
+          });
+        } else if (message.type === "utterance") {
+          const utterance = {
+            text: message.text || "",
+            start: message.start || 0,
+            end: message.end || 0,
+            speaker: message.speaker?.toString(),
+            confidence: message.confidence,
+            words: message.words?.map((word) => ({
+              text: word.word || word.text,
+              start: word.start,
+              end: word.end,
+              confidence: word.confidence
+            }))
+          };
+          callbacks?.onUtterance?.(utterance);
+        } else if (message.type === "metadata") {
+          callbacks?.onMetadata?.(message);
+        }
+      } catch (error) {
+        callbacks?.onError?.({
+          code: "PARSE_ERROR",
+          message: "Failed to parse WebSocket message",
+          details: error
+        });
+      }
+    });
+    ws.on("error", (error) => {
+      callbacks?.onError?.({
+        code: "WEBSOCKET_ERROR",
+        message: error.message,
+        details: error
+      });
+    });
+    ws.on("close", (code, reason) => {
+      sessionStatus = "closed";
+      callbacks?.onClose?.(code, reason.toString());
+    });
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("WebSocket connection timeout"));
+      }, 1e4);
+      ws.once("open", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      ws.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+    return {
+      id,
+      provider: this.name,
+      createdAt: /* @__PURE__ */ new Date(),
+      getStatus: () => sessionStatus,
+      sendAudio: async (chunk) => {
+        if (sessionStatus !== "open") {
+          throw new Error(`Cannot send audio: session is ${sessionStatus}`);
+        }
+        if (ws.readyState !== import_ws.default.OPEN) {
+          throw new Error("WebSocket is not open");
+        }
+        ws.send(chunk.data);
+        if (chunk.isLast) {
+          ws.send(
+            JSON.stringify({
+              type: "stop_recording"
+            })
+          );
+        }
+      },
+      close: async () => {
+        if (sessionStatus === "closed" || sessionStatus === "closing") {
+          return;
+        }
+        sessionStatus = "closing";
+        if (ws.readyState === import_ws.default.OPEN) {
+          ws.send(
+            JSON.stringify({
+              type: "stop_recording"
+            })
+          );
+        }
+        return new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            ws.terminate();
+            resolve();
+          }, 5e3);
+          ws.close();
+          ws.once("close", () => {
+            clearTimeout(timeout);
+            sessionStatus = "closed";
+            resolve();
+          });
+        });
+      }
+    };
+  }
+};
+function createGladiaAdapter(config) {
+  const adapter = new GladiaAdapter();
+  adapter.initialize(config);
+  return adapter;
+}
+
+// src/adapters/assemblyai-adapter.ts
+var import_axios2 = __toESM(require("axios"));
+var import_ws2 = __toESM(require("ws"));
+var AssemblyAIAdapter = class extends BaseAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "assemblyai";
+    this.capabilities = {
+      streaming: true,
+      diarization: true,
+      wordTimestamps: true,
+      languageDetection: true,
+      customVocabulary: true,
+      summarization: true,
+      sentimentAnalysis: true,
+      entityDetection: true,
+      piiRedaction: true
+    };
+    this.baseUrl = "https://api.assemblyai.com/v2";
+    this.wsBaseUrl = "wss://api.assemblyai.com/v2/realtime/ws";
+  }
+  initialize(config) {
+    super.initialize(config);
+    this.client = import_axios2.default.create({
+      baseURL: config.baseUrl || this.baseUrl,
+      timeout: config.timeout || 6e4,
+      headers: {
+        authorization: config.apiKey,
+        "Content-Type": "application/json",
+        ...config.headers
+      }
+    });
+  }
+  /**
+   * Submit audio for transcription
+   *
+   * Sends audio to AssemblyAI API for transcription. If a webhook URL is provided,
+   * returns immediately with the job ID. Otherwise, polls until completion.
+   *
+   * @param audio - Audio input (currently only URL type supported)
+   * @param options - Transcription options
+   * @param options.language - Language code (e.g., 'en', 'en_us', 'es', 'fr')
+   * @param options.languageDetection - Enable automatic language detection
+   * @param options.diarization - Enable speaker identification (speaker_labels)
+   * @param options.speakersExpected - Number of expected speakers
+   * @param options.summarization - Generate text summary
+   * @param options.sentimentAnalysis - Analyze sentiment of transcription
+   * @param options.entityDetection - Detect named entities (people, places, etc.)
+   * @param options.piiRedaction - Redact personally identifiable information
+   * @param options.customVocabulary - Words to boost in recognition
+   * @param options.webhookUrl - Callback URL for async results
+   * @returns Normalized transcription response
+   * @throws {Error} If audio type is not 'url' (file/stream not yet supported)
+   *
+   * @example Simple transcription
+   * ```typescript
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * });
+   * ```
+   *
+   * @example With advanced features
+   * ```typescript
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * }, {
+   *   language: 'en_us',
+   *   diarization: true,
+   *   speakersExpected: 3,
+   *   summarization: true,
+   *   sentimentAnalysis: true,
+   *   entityDetection: true,
+   *   customVocabulary: ['API', 'TypeScript', 'JavaScript']
+   * });
+   * ```
+   *
+   * @example With webhook (returns transcript ID immediately for polling)
+   * ```typescript
+   * // Submit transcription with webhook
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * }, {
+   *   webhookUrl: 'https://myapp.com/webhook/transcription',
+   *   language: 'en_us'
+   * });
+   *
+   * // Get transcript ID for polling
+   * const transcriptId = result.data?.id;
+   * console.log('Transcript ID:', transcriptId); // Use this to poll for status
+   *
+   * // Later: Poll for completion (if webhook fails or you want to check)
+   * const status = await adapter.getTranscript(transcriptId);
+   * if (status.data?.status === 'completed') {
+   *   console.log('Transcript:', status.data.text);
+   * }
+   * ```
+   */
+  async transcribe(audio, options) {
+    this.validateConfig();
+    try {
+      const payload = this.buildTranscriptionRequest(audio, options);
+      const response = await this.client.post("/transcript", payload);
+      const transcriptId = response.data.id;
+      if (options?.webhookUrl) {
+        return {
+          success: true,
+          provider: this.name,
+          data: {
+            id: transcriptId,
+            text: "",
+            status: "queued"
+          },
+          raw: response.data
+        };
+      }
+      return await this.pollForCompletion(transcriptId);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Get transcription result by ID
+   */
+  async getTranscript(transcriptId) {
+    this.validateConfig();
+    try {
+      const response = await this.client.get(`/transcript/${transcriptId}`);
+      return this.normalizeResponse(response.data);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Build AssemblyAI transcription request from unified options
+   */
+  buildTranscriptionRequest(audio, options) {
+    let audioUrl;
+    if (audio.type === "url") {
+      audioUrl = audio.url;
+    } else {
+      throw new Error(
+        "AssemblyAI adapter currently only supports URL-based audio input. Use audio.type='url'"
+      );
+    }
+    const request = {
+      audio_url: audioUrl
+    };
+    if (options) {
+      if (options.language) {
+        const languageCode = options.language.includes("_") ? options.language : `${options.language}_us`;
+        request.language_code = languageCode;
+      }
+      if (options.languageDetection) {
+        request.language_detection = true;
+      }
+      if (options.diarization) {
+        request.speaker_labels = true;
+        if (options.speakersExpected) {
+          request.speakers_expected = options.speakersExpected;
+        }
+      }
+      if (options.customVocabulary && options.customVocabulary.length > 0) {
+        request.word_boost = options.customVocabulary;
+        request.boost_param = "high";
+      }
+      if (options.summarization) {
+        request.summarization = true;
+        request.summary_model = "informative";
+        request.summary_type = "bullets";
+      }
+      if (options.sentimentAnalysis) {
+        request.sentiment_analysis = true;
+      }
+      if (options.entityDetection) {
+        request.entity_detection = true;
+      }
+      if (options.piiRedaction) {
+        request.redact_pii = true;
+      }
+      if (options.webhookUrl) {
+        request.webhook_url = options.webhookUrl;
+      }
+      request.punctuate = true;
+      request.format_text = true;
+    }
+    return request;
+  }
+  /**
+   * Normalize AssemblyAI response to unified format
+   */
+  normalizeResponse(response) {
+    let status;
+    switch (response.status) {
+      case "queued":
+        status = "queued";
+        break;
+      case "processing":
+        status = "processing";
+        break;
+      case "completed":
+        status = "completed";
+        break;
+      case "error":
+        status = "error";
+        break;
+      default:
+        status = "queued";
+    }
+    if (response.status === "error") {
+      return {
+        success: false,
+        provider: this.name,
+        error: {
+          code: "TRANSCRIPTION_ERROR",
+          message: response.error || "Transcription failed"
+        },
+        raw: response
+      };
+    }
+    return {
+      success: true,
+      provider: this.name,
+      data: {
+        id: response.id,
+        text: response.text || "",
+        confidence: response.confidence !== null ? response.confidence : void 0,
+        status,
+        language: response.language_code,
+        duration: response.audio_duration ? response.audio_duration / 1e3 : void 0,
+        // Convert ms to seconds
+        speakers: this.extractSpeakers(response),
+        words: this.extractWords(response),
+        utterances: this.extractUtterances(response),
+        summary: response.summary || void 0,
+        metadata: {
+          audioUrl: response.audio_url,
+          entities: response.entities,
+          sentimentAnalysis: response.sentiment_analysis_results,
+          contentModeration: response.content_safety_labels
+        }
+      },
+      raw: response
+    };
+  }
+  /**
+   * Extract speaker information from AssemblyAI response
+   */
+  extractSpeakers(transcript) {
+    if (!transcript.utterances || transcript.utterances.length === 0) {
+      return void 0;
+    }
+    const speakerSet = /* @__PURE__ */ new Set();
+    transcript.utterances.forEach((utterance) => {
+      if (utterance.speaker) {
+        speakerSet.add(utterance.speaker);
+      }
+    });
+    if (speakerSet.size === 0) {
+      return void 0;
+    }
+    return Array.from(speakerSet).map((speakerId) => ({
+      id: speakerId,
+      label: speakerId
+      // AssemblyAI uses format like "A", "B", "C"
+    }));
+  }
+  /**
+   * Extract word timestamps from AssemblyAI response
+   */
+  extractWords(transcript) {
+    if (!transcript.words || transcript.words.length === 0) {
+      return void 0;
+    }
+    return transcript.words.map((word) => ({
+      text: word.text,
+      start: word.start / 1e3,
+      // Convert ms to seconds
+      end: word.end / 1e3,
+      // Convert ms to seconds
+      confidence: word.confidence,
+      speaker: word.speaker || void 0
+    }));
+  }
+  /**
+   * Extract utterances from AssemblyAI response
+   */
+  extractUtterances(transcript) {
+    if (!transcript.utterances || transcript.utterances.length === 0) {
+      return void 0;
+    }
+    return transcript.utterances.map((utterance) => ({
+      text: utterance.text,
+      start: utterance.start / 1e3,
+      // Convert ms to seconds
+      end: utterance.end / 1e3,
+      // Convert ms to seconds
+      speaker: utterance.speaker || void 0,
+      confidence: utterance.confidence,
+      words: utterance.words.map((word) => ({
+        text: word.text,
+        start: word.start / 1e3,
+        end: word.end / 1e3,
+        confidence: word.confidence
+      }))
+    }));
+  }
+  /**
+   * Poll for transcription completion
+   */
+  async pollForCompletion(transcriptId, maxAttempts = 60, intervalMs = 3e3) {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const result = await this.getTranscript(transcriptId);
+      if (!result.success) {
+        return result;
+      }
+      const status = result.data?.status;
+      if (status === "completed") {
+        return result;
+      }
+      if (status === "error") {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "TRANSCRIPTION_ERROR",
+            message: "Transcription failed"
+          },
+          raw: result.raw
+        };
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return {
+      success: false,
+      provider: this.name,
+      error: {
+        code: "POLLING_TIMEOUT",
+        message: `Transcription did not complete after ${maxAttempts} attempts`
+      }
+    };
+  }
+  /**
+   * Stream audio for real-time transcription
+   *
+   * Creates a WebSocket connection to AssemblyAI for streaming transcription.
+   * First obtains a temporary token, then connects and streams audio chunks.
+   *
+   * @param options - Streaming configuration options
+   * @param callbacks - Event callbacks for transcription results
+   * @returns Promise that resolves with a StreamingSession
+   *
+   * @example Real-time streaming
+   * ```typescript
+   * const session = await adapter.transcribeStream({
+   *   encoding: 'pcm_s16le',
+   *   sampleRate: 16000,
+   *   language: 'en',
+   *   interimResults: true
+   * }, {
+   *   onOpen: () => console.log('Connected'),
+   *   onTranscript: (event) => {
+   *     if (event.isFinal) {
+   *       console.log('Final:', event.text);
+   *     } else {
+   *       console.log('Interim:', event.text);
+   *     }
+   *   },
+   *   onError: (error) => console.error('Error:', error),
+   *   onClose: () => console.log('Disconnected')
+   * });
+   *
+   * // Send audio chunks
+   * const audioChunk = getAudioChunk(); // Your audio source
+   * await session.sendAudio({ data: audioChunk });
+   *
+   * // Close when done
+   * await session.close();
+   * ```
+   */
+  async transcribeStream(options, callbacks) {
+    this.validateConfig();
+    const tokenResponse = await this.client.post("/realtime/token", {
+      expires_in: 3600
+      // Token expires in 1 hour
+    });
+    const token = tokenResponse.data.token;
+    const wsUrl = `${this.wsBaseUrl}?sample_rate=${options?.sampleRate || 16e3}&token=${token}`;
+    const ws = new import_ws2.default(wsUrl);
+    let sessionStatus = "connecting";
+    const sessionId = `assemblyai-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    ws.on("open", () => {
+      sessionStatus = "open";
+      callbacks?.onOpen?.();
+    });
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.message_type === "SessionBegins") {
+          callbacks?.onMetadata?.({
+            sessionId: message.session_id,
+            expiresAt: message.expires_at
+          });
+        } else if (message.message_type === "PartialTranscript") {
+          callbacks?.onTranscript?.({
+            type: "transcript",
+            text: message.text || "",
+            isFinal: false,
+            confidence: message.confidence,
+            words: message.words?.map((word) => ({
+              text: word.text,
+              start: word.start / 1e3,
+              end: word.end / 1e3,
+              confidence: word.confidence
+            })),
+            data: message
+          });
+        } else if (message.message_type === "FinalTranscript") {
+          callbacks?.onTranscript?.({
+            type: "transcript",
+            text: message.text || "",
+            isFinal: true,
+            confidence: message.confidence,
+            words: message.words?.map((word) => ({
+              text: word.text,
+              start: word.start / 1e3,
+              end: word.end / 1e3,
+              confidence: word.confidence
+            })),
+            data: message
+          });
+        } else if (message.message_type === "SessionTerminated") {
+          callbacks?.onMetadata?.({ terminated: true });
+        }
+      } catch (error) {
+        callbacks?.onError?.({
+          code: "PARSE_ERROR",
+          message: "Failed to parse WebSocket message",
+          details: error
+        });
+      }
+    });
+    ws.on("error", (error) => {
+      callbacks?.onError?.({
+        code: "WEBSOCKET_ERROR",
+        message: error.message,
+        details: error
+      });
+    });
+    ws.on("close", (code, reason) => {
+      sessionStatus = "closed";
+      callbacks?.onClose?.(code, reason.toString());
+    });
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("WebSocket connection timeout"));
+      }, 1e4);
+      ws.once("open", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      ws.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+    return {
+      id: sessionId,
+      provider: this.name,
+      createdAt: /* @__PURE__ */ new Date(),
+      getStatus: () => sessionStatus,
+      sendAudio: async (chunk) => {
+        if (sessionStatus !== "open") {
+          throw new Error(`Cannot send audio: session is ${sessionStatus}`);
+        }
+        if (ws.readyState !== import_ws2.default.OPEN) {
+          throw new Error("WebSocket is not open");
+        }
+        const base64Audio = chunk.data.toString("base64");
+        ws.send(
+          JSON.stringify({
+            audio_data: base64Audio
+          })
+        );
+        if (chunk.isLast) {
+          ws.send(
+            JSON.stringify({
+              terminate_session: true
+            })
+          );
+        }
+      },
+      close: async () => {
+        if (sessionStatus === "closed" || sessionStatus === "closing") {
+          return;
+        }
+        sessionStatus = "closing";
+        if (ws.readyState === import_ws2.default.OPEN) {
+          ws.send(
+            JSON.stringify({
+              terminate_session: true
+            })
+          );
+        }
+        return new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            ws.terminate();
+            resolve();
+          }, 5e3);
+          ws.close();
+          ws.once("close", () => {
+            clearTimeout(timeout);
+            sessionStatus = "closed";
+            resolve();
+          });
+        });
+      }
+    };
+  }
+};
+function createAssemblyAIAdapter(config) {
+  const adapter = new AssemblyAIAdapter();
+  adapter.initialize(config);
+  return adapter;
+}
+
+// src/adapters/deepgram-adapter.ts
+var import_axios3 = __toESM(require("axios"));
+var import_ws3 = __toESM(require("ws"));
+var DeepgramAdapter = class extends BaseAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "deepgram";
+    this.capabilities = {
+      streaming: true,
+      diarization: true,
+      wordTimestamps: true,
+      languageDetection: true,
+      customVocabulary: true,
+      summarization: true,
+      sentimentAnalysis: true,
+      entityDetection: true,
+      piiRedaction: true
+    };
+    this.baseUrl = "https://api.deepgram.com/v1";
+    this.wsBaseUrl = "wss://api.deepgram.com/v1/listen";
+  }
+  initialize(config) {
+    super.initialize(config);
+    this.client = import_axios3.default.create({
+      baseURL: config.baseUrl || this.baseUrl,
+      timeout: config.timeout || 6e4,
+      headers: {
+        Authorization: `Token ${config.apiKey}`,
+        "Content-Type": "application/json",
+        ...config.headers
+      }
+    });
+  }
+  /**
+   * Submit audio for transcription
+   *
+   * Sends audio to Deepgram API for transcription. Deepgram processes
+   * synchronously and returns results immediately (no polling required).
+   *
+   * @param audio - Audio input (URL or file buffer)
+   * @param options - Transcription options
+   * @param options.language - Language code (e.g., 'en', 'es', 'fr')
+   * @param options.languageDetection - Enable automatic language detection
+   * @param options.diarization - Enable speaker identification (diarize)
+   * @param options.speakersExpected - Expected number of speakers
+   * @param options.summarization - Generate text summary
+   * @param options.sentimentAnalysis - Analyze sentiment
+   * @param options.entityDetection - Detect named entities
+   * @param options.piiRedaction - Redact personally identifiable information
+   * @param options.customVocabulary - Keywords to boost in recognition
+   * @param options.webhookUrl - Callback URL for async processing
+   * @returns Normalized transcription response
+   *
+   * @example Simple transcription
+   * ```typescript
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * });
+   * ```
+   *
+   * @example With advanced features
+   * ```typescript
+   * const result = await adapter.transcribe({
+   *   type: 'url',
+   *   url: 'https://example.com/meeting.mp3'
+   * }, {
+   *   language: 'en',
+   *   diarization: true,
+   *   summarization: true,
+   *   sentimentAnalysis: true,
+   *   entityDetection: true,
+   *   customVocabulary: ['API', 'TypeScript', 'JavaScript']
+   * });
+   * ```
+   */
+  async transcribe(audio, options) {
+    this.validateConfig();
+    try {
+      const params = this.buildTranscriptionParams(options);
+      let response;
+      if (audio.type === "url") {
+        response = await this.client.post(
+          "/listen",
+          { url: audio.url },
+          { params }
+        ).then((res) => res.data);
+      } else if (audio.type === "file") {
+        response = await this.client.post("/listen", audio.file, {
+          params,
+          headers: {
+            "Content-Type": "audio/*"
+          }
+        }).then((res) => res.data);
+      } else {
+        throw new Error(
+          "Deepgram adapter does not support stream type for pre-recorded transcription. Use transcribeStream() for real-time streaming."
+        );
+      }
+      return this.normalizeResponse(response);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Get transcription result by ID
+   *
+   * Note: Deepgram processes synchronously, so this method is primarily
+   * for retrieving cached results if you've stored the request ID.
+   * The initial transcribe() call already returns complete results.
+   *
+   * @param transcriptId - Request ID from Deepgram
+   * @returns Normalized transcription response
+   */
+  async getTranscript(transcriptId) {
+    this.validateConfig();
+    return {
+      success: false,
+      provider: this.name,
+      error: {
+        code: "NOT_SUPPORTED",
+        message: "Deepgram returns transcription results immediately. Store the response from transcribe() instead of using getTranscript()."
+      }
+    };
+  }
+  /**
+   * Build Deepgram transcription parameters from unified options
+   */
+  buildTranscriptionParams(options) {
+    const params = {};
+    if (!options) {
+      return params;
+    }
+    if (options.language) {
+      params.language = options.language;
+    }
+    if (options.languageDetection) {
+      params.detect_language = true;
+    }
+    if (options.diarization) {
+      params.diarize = true;
+    }
+    if (options.customVocabulary && options.customVocabulary.length > 0) {
+      params.keywords = options.customVocabulary;
+    }
+    if (options.summarization) {
+      params.summarize = true;
+    }
+    if (options.sentimentAnalysis) {
+      params.sentiment = true;
+    }
+    if (options.entityDetection) {
+      params.detect_entities = true;
+    }
+    if (options.piiRedaction) {
+      params.redact = true;
+    }
+    if (options.webhookUrl) {
+      params.callback = options.webhookUrl;
+    }
+    params.punctuate = true;
+    params.utterances = true;
+    params.smart_format = true;
+    return params;
+  }
+  /**
+   * Normalize Deepgram response to unified format
+   */
+  normalizeResponse(response) {
+    const channel = response.results.channels?.[0];
+    const alternative = channel?.alternatives?.[0];
+    if (!alternative) {
+      return {
+        success: false,
+        provider: this.name,
+        error: {
+          code: "NO_RESULTS",
+          message: "No transcription results returned by Deepgram"
+        },
+        raw: response
+      };
+    }
+    return {
+      success: true,
+      provider: this.name,
+      data: {
+        id: response.metadata?.request_id || "",
+        text: alternative.transcript || "",
+        confidence: alternative.confidence,
+        status: "completed",
+        // Deepgram returns completed results immediately
+        language: channel?.detected_language || void 0,
+        duration: response.metadata?.duration,
+        speakers: this.extractSpeakers(response),
+        words: this.extractWords(alternative),
+        utterances: this.extractUtterances(response),
+        summary: this.extractSummary(alternative),
+        metadata: {
+          modelInfo: response.metadata?.model_info,
+          channels: response.metadata?.channels,
+          sentiment: response.results.sentiments,
+          intents: response.results.intents,
+          topics: response.results.topics
+        }
+      },
+      raw: response
+    };
+  }
+  /**
+   * Extract speaker information from Deepgram response
+   */
+  extractSpeakers(response) {
+    const utterances = response.results.utterances;
+    if (!utterances || utterances.length === 0) {
+      return void 0;
+    }
+    const speakerSet = /* @__PURE__ */ new Set();
+    utterances.forEach((utterance) => {
+      if (utterance.speaker !== void 0) {
+        speakerSet.add(utterance.speaker);
+      }
+    });
+    if (speakerSet.size === 0) {
+      return void 0;
+    }
+    return Array.from(speakerSet).map((speakerId) => ({
+      id: speakerId.toString(),
+      label: `Speaker ${speakerId}`
+    }));
+  }
+  /**
+   * Extract word timestamps from Deepgram response
+   */
+  extractWords(alternative) {
+    if (!alternative.words || alternative.words.length === 0) {
+      return void 0;
+    }
+    return alternative.words.map(
+      (word) => ({
+        text: word.word || "",
+        start: word.start || 0,
+        end: word.end || 0,
+        confidence: word.confidence,
+        speaker: void 0
+        // Speaker info is at utterance level, not word level
+      })
+    );
+  }
+  /**
+   * Extract utterances from Deepgram response
+   */
+  extractUtterances(response) {
+    const utterances = response.results.utterances;
+    if (!utterances || utterances.length === 0) {
+      return void 0;
+    }
+    return utterances.map((utterance) => ({
+      text: utterance.transcript || "",
+      start: utterance.start || 0,
+      end: utterance.end || 0,
+      speaker: utterance.speaker?.toString(),
+      confidence: utterance.confidence,
+      words: utterance.words?.map((word) => ({
+        text: word.word || "",
+        start: word.start || 0,
+        end: word.end || 0,
+        confidence: word.confidence
+      }))
+    }));
+  }
+  /**
+   * Extract summary from Deepgram response
+   */
+  extractSummary(alternative) {
+    if (!alternative.summaries || alternative.summaries.length === 0) {
+      return void 0;
+    }
+    return alternative.summaries.map((summary) => summary.summary).filter(Boolean).join(" ");
+  }
+  /**
+   * Stream audio for real-time transcription
+   *
+   * Creates a WebSocket connection to Deepgram for streaming transcription.
+   * Send audio chunks via session.sendAudio() and receive results via callbacks.
+   *
+   * @param options - Streaming configuration options
+   * @param callbacks - Event callbacks for transcription results
+   * @returns Promise that resolves with a StreamingSession
+   *
+   * @example Real-time streaming
+   * ```typescript
+   * const session = await adapter.transcribeStream({
+   *   encoding: 'linear16',
+   *   sampleRate: 16000,
+   *   channels: 1,
+   *   language: 'en',
+   *   diarization: true,
+   *   interimResults: true
+   * }, {
+   *   onOpen: () => console.log('Connected'),
+   *   onTranscript: (event) => {
+   *     if (event.isFinal) {
+   *       console.log('Final:', event.text);
+   *     } else {
+   *       console.log('Interim:', event.text);
+   *     }
+   *   },
+   *   onError: (error) => console.error('Error:', error),
+   *   onClose: () => console.log('Disconnected')
+   * });
+   *
+   * // Send audio chunks
+   * const audioChunk = getAudioChunk(); // Your audio source
+   * await session.sendAudio({ data: audioChunk });
+   *
+   * // Close when done
+   * await session.close();
+   * ```
+   */
+  async transcribeStream(options, callbacks) {
+    this.validateConfig();
+    const params = new URLSearchParams();
+    if (options?.encoding) params.append("encoding", options.encoding);
+    if (options?.sampleRate) params.append("sample_rate", options.sampleRate.toString());
+    if (options?.channels) params.append("channels", options.channels.toString());
+    if (options?.language) params.append("language", options.language);
+    if (options?.languageDetection) params.append("detect_language", "true");
+    if (options?.diarization) params.append("diarize", "true");
+    if (options?.interimResults) params.append("interim_results", "true");
+    if (options?.summarization) params.append("summarize", "true");
+    if (options?.sentimentAnalysis) params.append("sentiment", "true");
+    if (options?.entityDetection) params.append("detect_entities", "true");
+    if (options?.piiRedaction) params.append("redact", "pii");
+    if (options?.customVocabulary && options.customVocabulary.length > 0) {
+      params.append("keywords", options.customVocabulary.join(","));
+    }
+    const wsUrl = `${this.wsBaseUrl}?${params.toString()}`;
+    const ws = new import_ws3.default(wsUrl, {
+      headers: {
+        Authorization: `Token ${this.config.apiKey}`
+      }
+    });
+    let sessionStatus = "connecting";
+    const sessionId = `deepgram-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    ws.on("open", () => {
+      sessionStatus = "open";
+      callbacks?.onOpen?.();
+    });
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.type === "Results") {
+          const result = message;
+          const channel = result.channel?.alternatives?.[0];
+          if (channel) {
+            const transcript = channel.transcript || "";
+            const isFinal = message.is_final === true;
+            const words = channel.words?.map((word) => ({
+              text: word.word || "",
+              start: word.start || 0,
+              end: word.end || 0,
+              confidence: word.confidence
+            }));
+            callbacks?.onTranscript?.({
+              type: "transcript",
+              text: transcript,
+              isFinal,
+              words,
+              confidence: channel.confidence,
+              data: result
+            });
+          }
+        } else if (message.type === "UtteranceEnd") {
+          callbacks?.onMetadata?.(message);
+        } else if (message.type === "Metadata") {
+          callbacks?.onMetadata?.(message);
+        }
+      } catch (error) {
+        callbacks?.onError?.({
+          code: "PARSE_ERROR",
+          message: "Failed to parse WebSocket message",
+          details: error
+        });
+      }
+    });
+    ws.on("error", (error) => {
+      callbacks?.onError?.({
+        code: "WEBSOCKET_ERROR",
+        message: error.message,
+        details: error
+      });
+    });
+    ws.on("close", (code, reason) => {
+      sessionStatus = "closed";
+      callbacks?.onClose?.(code, reason.toString());
+    });
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("WebSocket connection timeout"));
+      }, 1e4);
+      ws.once("open", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      ws.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      });
+    });
+    return {
+      id: sessionId,
+      provider: this.name,
+      createdAt: /* @__PURE__ */ new Date(),
+      getStatus: () => sessionStatus,
+      sendAudio: async (chunk) => {
+        if (sessionStatus !== "open") {
+          throw new Error(`Cannot send audio: session is ${sessionStatus}`);
+        }
+        if (ws.readyState !== import_ws3.default.OPEN) {
+          throw new Error("WebSocket is not open");
+        }
+        ws.send(chunk.data);
+        if (chunk.isLast) {
+          ws.send(JSON.stringify({ type: "CloseStream" }));
+        }
+      },
+      close: async () => {
+        if (sessionStatus === "closed" || sessionStatus === "closing") {
+          return;
+        }
+        sessionStatus = "closing";
+        if (ws.readyState === import_ws3.default.OPEN) {
+          ws.send(JSON.stringify({ type: "CloseStream" }));
+        }
+        return new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            ws.terminate();
+            resolve();
+          }, 5e3);
+          ws.close();
+          ws.once("close", () => {
+            clearTimeout(timeout);
+            sessionStatus = "closed";
+            resolve();
+          });
+        });
+      }
+    };
+  }
+};
+function createDeepgramAdapter(config) {
+  const adapter = new DeepgramAdapter();
+  adapter.initialize(config);
+  return adapter;
+}
+
+// src/adapters/azure-stt-adapter.ts
+var import_axios4 = __toESM(require("axios"));
+var AzureSTTAdapter = class extends BaseAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "azure-stt";
+    this.capabilities = {
+      streaming: false,
+      // Batch transcription only
+      diarization: true,
+      wordTimestamps: true,
+      languageDetection: false,
+      customVocabulary: true,
+      summarization: false,
+      sentimentAnalysis: false,
+      entityDetection: false,
+      piiRedaction: false
+    };
+  }
+  initialize(config) {
+    super.initialize(config);
+    this.region = config.region || "eastus";
+    this.baseUrl = config.baseUrl || `https://${this.region}.api.cognitive.microsoft.com/speechtotext/v3.1`;
+    this.client = import_axios4.default.create({
+      baseURL: this.baseUrl,
+      timeout: config.timeout || 6e4,
+      headers: {
+        "Ocp-Apim-Subscription-Key": config.apiKey,
+        "Content-Type": "application/json",
+        ...config.headers
+      }
+    });
+  }
+  /**
+   * Submit audio for transcription
+   *
+   * Azure Speech-to-Text uses batch transcription which processes asynchronously.
+   * You need to poll getTranscript() to retrieve the completed transcription.
+   *
+   * @param audio - Audio input (URL only for batch transcription)
+   * @param options - Transcription options
+   * @returns Response with transcription ID for polling
+   */
+  async transcribe(audio, options) {
+    this.validateConfig();
+    if (audio.type !== "url") {
+      return {
+        success: false,
+        provider: this.name,
+        error: {
+          code: "INVALID_INPUT",
+          message: "Azure Speech-to-Text batch transcription only supports URL input"
+        }
+      };
+    }
+    try {
+      const transcriptionRequest = {
+        displayName: options?.metadata?.displayName || "SDK Transcription",
+        description: options?.metadata?.description || "",
+        locale: options?.language || "en-US",
+        contentUrls: [audio.url],
+        properties: this.buildTranscriptionProperties(options)
+      };
+      const response = await this.client.post(
+        "/transcriptions",
+        transcriptionRequest
+      );
+      const transcription = response.data;
+      return {
+        success: true,
+        provider: this.name,
+        data: {
+          id: transcription.self?.split("/").pop() || "",
+          text: "",
+          // Will be populated after polling
+          status: this.normalizeStatus(transcription.status),
+          language: transcription.locale,
+          createdAt: transcription.createdDateTime
+        },
+        raw: transcription
+      };
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Get transcription result by ID
+   *
+   * Poll this method to check transcription status and retrieve results.
+   *
+   * @param transcriptId - Transcription ID from Azure
+   * @returns Transcription response with status and results
+   */
+  async getTranscript(transcriptId) {
+    this.validateConfig();
+    try {
+      const statusResponse = await this.client.get(
+        `/transcriptions/${transcriptId}`
+      );
+      const transcription = statusResponse.data;
+      const status = this.normalizeStatus(transcription.status);
+      if (status !== "completed") {
+        return {
+          success: true,
+          provider: this.name,
+          data: {
+            id: transcriptId,
+            text: "",
+            status,
+            language: transcription.locale,
+            createdAt: transcription.createdDateTime
+          },
+          raw: transcription
+        };
+      }
+      if (!transcription.links?.files) {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "NO_RESULTS",
+            message: "Transcription completed but no result files available"
+          },
+          raw: transcription
+        };
+      }
+      const filesResponse = await this.client.get(transcription.links.files);
+      const files = filesResponse.data?.values || [];
+      const resultFile = files.find((file) => file.kind === "Transcription");
+      if (!resultFile?.links?.contentUrl) {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "NO_RESULTS",
+            message: "Transcription result file not found"
+          },
+          raw: transcription
+        };
+      }
+      const contentResponse = await import_axios4.default.get(resultFile.links.contentUrl);
+      const transcriptionData = contentResponse.data;
+      return this.normalizeResponse(transcription, transcriptionData);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Build Azure-specific transcription properties
+   */
+  buildTranscriptionProperties(options) {
+    const properties = {
+      wordLevelTimestampsEnabled: options?.wordTimestamps ?? true,
+      punctuationMode: "DictatedAndAutomatic",
+      profanityFilterMode: "Masked"
+    };
+    if (options?.diarization) {
+      properties.diarizationEnabled = true;
+      if (options.speakersExpected) {
+        properties.diarization = {
+          speakers: {
+            minCount: 1,
+            maxCount: options.speakersExpected
+          }
+        };
+      }
+    }
+    if (options?.customVocabulary && options.customVocabulary.length > 0) {
+      properties.customProperties = {
+        phrases: options.customVocabulary.join(",")
+      };
+    }
+    return properties;
+  }
+  /**
+   * Normalize Azure status to unified status
+   */
+  normalizeStatus(status) {
+    const statusStr = status?.toString().toLowerCase() || "";
+    if (statusStr.includes("succeeded")) return "completed";
+    if (statusStr.includes("running")) return "processing";
+    if (statusStr.includes("notstarted")) return "queued";
+    if (statusStr.includes("failed")) return "error";
+    return "queued";
+  }
+  /**
+   * Normalize Azure transcription response to unified format
+   */
+  normalizeResponse(transcription, transcriptionData) {
+    const combinedPhrases = transcriptionData.combinedRecognizedPhrases || [];
+    const recognizedPhrases = transcriptionData.recognizedPhrases || [];
+    const fullText = combinedPhrases.map((phrase) => phrase.display || phrase.lexical).join(" ") || "";
+    const words = recognizedPhrases.flatMap(
+      (phrase) => (phrase.nBest?.[0]?.words || []).map((word) => ({
+        text: word.word,
+        start: word.offsetInTicks / 1e7,
+        // Convert ticks to seconds
+        end: (word.offsetInTicks + word.durationInTicks) / 1e7,
+        confidence: word.confidence,
+        speaker: phrase.speaker !== void 0 ? phrase.speaker.toString() : void 0
+      }))
+    );
+    const speakers = recognizedPhrases.length > 0 && recognizedPhrases[0].speaker !== void 0 ? Array.from(
+      new Set(
+        recognizedPhrases.map((p) => p.speaker).filter((s) => s !== void 0)
+      )
+    ).map((speakerId) => ({
+      id: String(speakerId),
+      label: `Speaker ${speakerId}`
+    })) : void 0;
+    return {
+      success: true,
+      provider: this.name,
+      data: {
+        id: transcription.self?.split("/").pop() || "",
+        text: fullText,
+        confidence: recognizedPhrases[0]?.nBest?.[0]?.confidence,
+        status: "completed",
+        language: transcription.locale,
+        duration: transcriptionData.duration ? transcriptionData.duration / 1e7 : void 0,
+        speakers,
+        words: words.length > 0 ? words : void 0,
+        createdAt: transcription.createdDateTime,
+        completedAt: transcription.lastActionDateTime
+      },
+      raw: {
+        transcription,
+        transcriptionData
+      }
+    };
+  }
+};
+function createAzureSTTAdapter(config) {
+  const adapter = new AzureSTTAdapter();
+  adapter.initialize(config);
+  return adapter;
+}
+
+// src/adapters/openai-whisper-adapter.ts
+var import_axios5 = __toESM(require("axios"));
+var OpenAIWhisperAdapter = class extends BaseAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "openai-whisper";
+    this.capabilities = {
+      streaming: false,
+      // Synchronous only (no streaming API for transcription)
+      diarization: true,
+      // Available with gpt-4o-transcribe-diarize model
+      wordTimestamps: true,
+      languageDetection: false,
+      // Language should be provided for best accuracy
+      customVocabulary: false,
+      // Uses prompt instead
+      summarization: false,
+      sentimentAnalysis: false,
+      entityDetection: false,
+      piiRedaction: false
+    };
+    this.baseUrl = "https://api.openai.com/v1";
+  }
+  initialize(config) {
+    super.initialize(config);
+    this.baseUrl = config.baseUrl || this.baseUrl;
+    this.client = import_axios5.default.create({
+      baseURL: this.baseUrl,
+      timeout: config.timeout || 12e4,
+      // 2 minutes default (audio processing can take time)
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "multipart/form-data",
+        ...config.headers
+      }
+    });
+  }
+  /**
+   * Submit audio for transcription
+   *
+   * OpenAI Whisper API processes audio synchronously and returns results immediately.
+   * Supports multiple models with different capabilities:
+   * - whisper-1: Open source Whisper V2 model
+   * - gpt-4o-transcribe: More accurate GPT-4o based transcription
+   * - gpt-4o-mini-transcribe: Faster, cost-effective GPT-4o mini
+   * - gpt-4o-transcribe-diarize: GPT-4o with speaker diarization
+   *
+   * @param audio - Audio input (URL or Buffer)
+   * @param options - Transcription options
+   * @returns Transcription response with full results
+   */
+  async transcribe(audio, options) {
+    this.validateConfig();
+    try {
+      let audioData;
+      let fileName = "audio.mp3";
+      if (audio.type === "url") {
+        const response2 = await import_axios5.default.get(audio.url, {
+          responseType: "arraybuffer"
+        });
+        audioData = Buffer.from(response2.data);
+        const urlPath = new URL(audio.url).pathname;
+        const extractedName = urlPath.split("/").pop();
+        if (extractedName) {
+          fileName = extractedName;
+        }
+      } else if (audio.type === "file") {
+        audioData = audio.file;
+        fileName = audio.filename || fileName;
+      } else {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "INVALID_INPUT",
+            message: "OpenAI Whisper only supports URL and File audio input (not stream)"
+          }
+        };
+      }
+      const model = this.selectModel(options);
+      const isDiarization = model === "gpt-4o-transcribe-diarize";
+      const needsWords = options?.wordTimestamps === true;
+      const requestBody = {
+        file: audioData,
+        model
+      };
+      if (options?.language) {
+        requestBody.language = options.language;
+      }
+      if (options?.metadata?.prompt) {
+        requestBody.prompt = options.metadata.prompt;
+      }
+      if (options?.metadata?.temperature !== void 0) {
+        requestBody.temperature = options.metadata.temperature;
+      }
+      if (isDiarization) {
+        requestBody.response_format = "diarized_json";
+        if (options?.metadata?.knownSpeakerNames) {
+          requestBody["known_speaker_names"] = options.metadata.knownSpeakerNames;
+        }
+        if (options?.metadata?.knownSpeakerReferences) {
+          requestBody["known_speaker_references"] = options.metadata.knownSpeakerReferences;
+        }
+      } else if (needsWords || options?.diarization) {
+        requestBody.response_format = "verbose_json";
+        if (needsWords) {
+          requestBody.timestamp_granularities = ["word", "segment"];
+        }
+      } else {
+        requestBody.response_format = "json";
+      }
+      const response = await this.client.post("/audio/transcriptions", requestBody, {
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+      return this.normalizeResponse(response.data, model, isDiarization);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * OpenAI Whisper returns results synchronously, so getTranscript is not needed.
+   * This method exists for interface compatibility but will return an error.
+   */
+  async getTranscript(transcriptId) {
+    return {
+      success: false,
+      provider: this.name,
+      error: {
+        code: "NOT_SUPPORTED",
+        message: "OpenAI Whisper processes transcriptions synchronously. Use transcribe() method directly."
+      }
+    };
+  }
+  /**
+   * Select appropriate model based on transcription options
+   */
+  selectModel(options) {
+    if (options?.metadata?.model) {
+      return options.metadata.model;
+    }
+    if (options?.diarization) {
+      return "gpt-4o-transcribe-diarize";
+    }
+    return "gpt-4o-transcribe";
+  }
+  /**
+   * Normalize OpenAI response to unified format
+   */
+  normalizeResponse(response, model, isDiarization) {
+    if ("text" in response && Object.keys(response).length === 1) {
+      return {
+        success: true,
+        provider: this.name,
+        data: {
+          id: `openai-${Date.now()}`,
+          text: response.text,
+          status: "completed",
+          language: void 0,
+          confidence: void 0
+        },
+        raw: response
+      };
+    }
+    if (isDiarization && "segments" in response) {
+      const diarizedResponse = response;
+      const speakerSet = new Set(diarizedResponse.segments.map((seg) => seg.speaker));
+      const speakers = Array.from(speakerSet).map((speaker) => ({
+        id: speaker,
+        label: speaker
+        // Already labeled by OpenAI (A, B, C or custom names)
+      }));
+      const utterances = diarizedResponse.segments.map((segment) => ({
+        speaker: segment.speaker,
+        text: segment.text,
+        start: segment.start,
+        end: segment.end,
+        confidence: void 0
+      }));
+      return {
+        success: true,
+        provider: this.name,
+        data: {
+          id: `openai-${Date.now()}`,
+          text: diarizedResponse.text,
+          status: "completed",
+          language: void 0,
+          duration: diarizedResponse.duration,
+          speakers,
+          utterances
+        },
+        raw: response
+      };
+    }
+    if ("duration" in response && "language" in response) {
+      const verboseResponse = response;
+      const words = verboseResponse.words?.map((word) => ({
+        text: word.word,
+        start: word.start,
+        end: word.end,
+        confidence: void 0
+      }));
+      return {
+        success: true,
+        provider: this.name,
+        data: {
+          id: `openai-${Date.now()}`,
+          text: verboseResponse.text,
+          status: "completed",
+          language: verboseResponse.language,
+          duration: verboseResponse.duration,
+          words
+        },
+        raw: response
+      };
+    }
+    return {
+      success: true,
+      provider: this.name,
+      data: {
+        id: `openai-${Date.now()}`,
+        text: "text" in response ? response.text : "",
+        status: "completed"
+      },
+      raw: response
+    };
+  }
+};
+function createOpenAIWhisperAdapter(config) {
+  const adapter = new OpenAIWhisperAdapter();
+  adapter.initialize(config);
+  return adapter;
+}
+
+// src/adapters/speechmatics-adapter.ts
+var import_axios6 = __toESM(require("axios"));
+var SpeechmaticsAdapter = class extends BaseAdapter {
+  constructor() {
+    super(...arguments);
+    this.name = "speechmatics";
+    this.capabilities = {
+      streaming: false,
+      // Batch only (streaming available via separate WebSocket API)
+      diarization: true,
+      wordTimestamps: true,
+      languageDetection: false,
+      customVocabulary: true,
+      summarization: true,
+      sentimentAnalysis: true,
+      entityDetection: true,
+      piiRedaction: false
+    };
+    this.baseUrl = "https://asr.api.speechmatics.com/v2";
+  }
+  initialize(config) {
+    super.initialize(config);
+    this.baseUrl = config.baseUrl || this.baseUrl;
+    this.client = import_axios6.default.create({
+      baseURL: this.baseUrl,
+      timeout: config.timeout || 12e4,
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        ...config.headers
+      }
+    });
+  }
+  /**
+   * Submit audio for transcription
+   *
+   * Speechmatics uses async batch processing. Returns a job ID immediately.
+   * Poll getTranscript() to retrieve results.
+   *
+   * @param audio - Audio input (URL or file)
+   * @param options - Transcription options
+   * @returns Job submission response with ID for polling
+   */
+  async transcribe(audio, options) {
+    this.validateConfig();
+    try {
+      const jobConfig = {
+        type: "transcription",
+        transcription_config: {
+          language: options?.language || "en",
+          operating_point: options?.metadata?.operating_point || "standard"
+        }
+      };
+      if (options?.diarization) {
+        jobConfig.transcription_config.diarization = "speaker";
+        if (options.speakersExpected) {
+          jobConfig.transcription_config.speaker_diarization_config = {
+            max_speakers: options.speakersExpected
+          };
+        }
+      }
+      if (options?.sentimentAnalysis) {
+        jobConfig.transcription_config.enable_sentiment_analysis = true;
+      }
+      if (options?.summarization && options?.metadata?.summary_type) {
+        jobConfig.transcription_config.summarization_config = {
+          type: options.metadata.summary_type,
+          length: options.metadata.summary_length || "medium"
+        };
+      }
+      if (options?.customVocabulary && options.customVocabulary.length > 0) {
+        jobConfig.transcription_config.additional_vocab = options.customVocabulary;
+      }
+      let requestBody;
+      let headers = {};
+      if (audio.type === "url") {
+        jobConfig.fetch_data = {
+          url: audio.url
+        };
+        requestBody = { config: JSON.stringify(jobConfig) };
+        headers = { "Content-Type": "application/json" };
+      } else if (audio.type === "file") {
+        requestBody = {
+          config: JSON.stringify(jobConfig),
+          data_file: audio.file
+        };
+        headers = { "Content-Type": "multipart/form-data" };
+      } else {
+        return {
+          success: false,
+          provider: this.name,
+          error: {
+            code: "INVALID_INPUT",
+            message: "Speechmatics only supports URL and File audio input"
+          }
+        };
+      }
+      const response = await this.client.post("/jobs", requestBody, { headers });
+      return {
+        success: true,
+        provider: this.name,
+        data: {
+          id: response.data.id,
+          text: "",
+          status: "queued",
+          createdAt: response.data.created_at
+        },
+        raw: response.data
+      };
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Get transcription result by job ID
+   *
+   * Poll this method to check job status and retrieve completed transcription.
+   *
+   * @param transcriptId - Job ID from Speechmatics
+   * @returns Transcription response with status and results
+   */
+  async getTranscript(transcriptId) {
+    this.validateConfig();
+    try {
+      const statusResponse = await this.client.get(`/jobs/${transcriptId}`);
+      const status = this.normalizeStatus(statusResponse.data.job.status);
+      if (status !== "completed") {
+        return {
+          success: true,
+          provider: this.name,
+          data: {
+            id: transcriptId,
+            text: "",
+            status,
+            createdAt: statusResponse.data.job.created_at
+          },
+          raw: statusResponse.data
+        };
+      }
+      const transcriptResponse = await this.client.get(
+        `/jobs/${transcriptId}/transcript`
+      );
+      return this.normalizeResponse(transcriptResponse.data);
+    } catch (error) {
+      return this.createErrorResponse(error);
+    }
+  }
+  /**
+   * Normalize Speechmatics status to unified status
+   */
+  normalizeStatus(status) {
+    switch (status) {
+      case "running":
+        return "processing";
+      case "done":
+        return "completed";
+      case "rejected":
+      case "expired":
+        return "error";
+      default:
+        return "queued";
+    }
+  }
+  /**
+   * Normalize Speechmatics response to unified format
+   */
+  normalizeResponse(response) {
+    const text = response.results.filter((r) => r.type === "word").map((r) => r.alternatives[0]?.content || "").join(" ");
+    const words = response.results.filter((r) => r.type === "word").map((result) => ({
+      text: result.alternatives[0]?.content || "",
+      start: result.start_time,
+      end: result.end_time,
+      confidence: result.alternatives[0]?.confidence,
+      speaker: result.alternatives[0]?.speaker
+    }));
+    const speakerSet = /* @__PURE__ */ new Set();
+    response.results.forEach((r) => {
+      const speaker = r.alternatives[0]?.speaker;
+      if (speaker) speakerSet.add(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").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,
+              end: prevResult?.end_time || result.start_time
+            });
+          }
+          currentSpeaker = speaker;
+          currentUtterance = [word];
+          utteranceStart = result.start_time;
+        } 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
+        });
+      }
+    }
+    return {
+      success: true,
+      provider: this.name,
+      data: {
+        id: response.job.id,
+        text,
+        status: "completed",
+        language: response.metadata.transcription_config.language,
+        duration: response.job.duration,
+        speakers,
+        words: words.length > 0 ? words : void 0,
+        utterances: utterances.length > 0 ? utterances : void 0,
+        summary: response.summary?.content,
+        createdAt: response.job.created_at
+      },
+      raw: response
+    };
+  }
+};
+function createSpeechmaticsAdapter(config) {
+  const adapter = new SpeechmaticsAdapter();
+  adapter.initialize(config);
+  return adapter;
+}
+
+// src/webhooks/base-webhook.ts
+var BaseWebhookHandler = class {
+  /**
+   * Validate webhook payload structure
+   *
+   * Checks if payload has required fields and correct types
+   *
+   * @param payload - Raw webhook payload
+   * @param options - Optional context (query params, headers, etc.)
+   * @returns Validation result with details
+   */
+  validate(payload, options) {
+    try {
+      if (!this.matches(payload, options)) {
+        return {
+          valid: false,
+          error: `Payload does not match ${this.provider} webhook format`
+        };
+      }
+      const event = this.parse(payload, options);
+      if (!event.provider || !event.eventType) {
+        return {
+          valid: false,
+          error: "Parsed event missing required fields"
+        };
+      }
+      return {
+        valid: true,
+        provider: this.provider,
+        details: {
+          eventType: event.eventType,
+          success: event.success
+        }
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        details: { error }
+      };
+    }
+  }
+  /**
+   * Helper method to create error response
+   */
+  createErrorEvent(payload, errorMessage) {
+    return {
+      success: false,
+      provider: this.provider,
+      eventType: "transcription.failed",
+      data: {
+        id: "",
+        status: "error",
+        error: errorMessage
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      raw: payload
+    };
+  }
+};
+
+// src/webhooks/gladia-webhook.ts
+var GladiaWebhookHandler = class extends BaseWebhookHandler {
+  constructor() {
+    super(...arguments);
+    this.provider = "gladia";
+  }
+  /**
+   * Check if payload matches Gladia webhook format
+   */
+  matches(payload, _options) {
+    if (!payload || typeof payload !== "object") {
+      return false;
+    }
+    const obj = payload;
+    if (!("event" in obj) || !("payload" in obj)) {
+      return false;
+    }
+    if (typeof obj.event !== "string") {
+      return false;
+    }
+    if (!obj.event.startsWith("transcription.")) {
+      return false;
+    }
+    if (!obj.payload || typeof obj.payload !== "object") {
+      return false;
+    }
+    const payloadObj = obj.payload;
+    return typeof payloadObj.id === "string";
+  }
+  /**
+   * Parse Gladia webhook payload to unified format
+   */
+  parse(payload, _options) {
+    if (!this.matches(payload)) {
+      return this.createErrorEvent(payload, "Invalid Gladia webhook payload");
+    }
+    const webhookPayload = payload;
+    const jobId = webhookPayload.payload.id;
+    const event = webhookPayload.event;
+    if (event === "transcription.created") {
+      return {
+        success: true,
+        provider: this.provider,
+        eventType: "transcription.created",
+        data: {
+          id: jobId,
+          status: "queued"
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: payload
+      };
+    }
+    if (event === "transcription.success") {
+      return {
+        success: true,
+        provider: this.provider,
+        eventType: "transcription.completed",
+        data: {
+          id: jobId,
+          status: "completed"
+          // Note: Full transcript data needs to be fetched via API
+          // using GladiaAdapter.getTranscript(jobId)
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: payload
+      };
+    }
+    if (event === "transcription.error") {
+      return {
+        success: false,
+        provider: this.provider,
+        eventType: "transcription.failed",
+        data: {
+          id: jobId,
+          status: "error",
+          error: "Transcription failed"
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: payload
+      };
+    }
+    return this.createErrorEvent(payload, `Unknown Gladia webhook event: ${event}`);
+  }
+  /**
+   * Verify Gladia webhook signature
+   *
+   * Note: As of the current API version, Gladia does not provide
+   * webhook signature verification. This method is a placeholder
+   * for future implementation.
+   *
+   * @param payload - Webhook payload
+   * @param options - Verification options
+   * @returns Always returns true (no verification available)
+   */
+  verify() {
+    return true;
+  }
+};
+function createGladiaWebhookHandler() {
+  return new GladiaWebhookHandler();
+}
+
+// src/webhooks/assemblyai-webhook.ts
+var import_node_crypto = __toESM(require("crypto"));
+var AssemblyAIWebhookHandler = class extends BaseWebhookHandler {
+  constructor() {
+    super(...arguments);
+    this.provider = "assemblyai";
+  }
+  /**
+   * Check if payload matches AssemblyAI webhook format
+   */
+  matches(payload, _options) {
+    if (!payload || typeof payload !== "object") {
+      return false;
+    }
+    const obj = payload;
+    if (!("transcript_id" in obj) || !("status" in obj)) {
+      return false;
+    }
+    if (typeof obj.transcript_id !== "string") {
+      return false;
+    }
+    if (obj.status !== "completed" && obj.status !== "error") {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Parse AssemblyAI webhook payload to unified format
+   */
+  parse(payload, _options) {
+    if (!this.matches(payload)) {
+      return this.createErrorEvent(payload, "Invalid AssemblyAI webhook payload");
+    }
+    const notification = payload;
+    const transcriptId = notification.transcript_id;
+    const status = notification.status;
+    if (status === "completed") {
+      return {
+        success: true,
+        provider: this.provider,
+        eventType: "transcription.completed",
+        data: {
+          id: transcriptId,
+          status: "completed"
+          // Note: Full transcript data needs to be fetched via API
+          // using AssemblyAIAdapter.getTranscript(transcriptId)
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: payload
+      };
+    }
+    if (status === "error") {
+      return {
+        success: false,
+        provider: this.provider,
+        eventType: "transcription.failed",
+        data: {
+          id: transcriptId,
+          status: "error",
+          error: "Transcription failed"
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: payload
+      };
+    }
+    return this.createErrorEvent(payload, `Unknown AssemblyAI status: ${status}`);
+  }
+  /**
+   * Verify AssemblyAI webhook signature
+   *
+   * AssemblyAI uses HMAC-SHA256 for webhook signature verification.
+   * The signature is sent in the X-AssemblyAI-Signature header.
+   *
+   * @param payload - Webhook payload
+   * @param options - Verification options with signature and secret
+   * @returns true if signature is valid
+   *
+   * @example
+   * ```typescript
+   * const isValid = handler.verify(req.body, {
+   *   signature: req.headers['x-assemblyai-signature'],
+   *   secret: process.env.ASSEMBLYAI_WEBHOOK_SECRET,
+   *   rawBody: req.rawBody // Raw request body as string or Buffer
+   * });
+   * ```
+   */
+  verify(payload, options) {
+    if (!options.signature || !options.secret) {
+      return false;
+    }
+    try {
+      const body = options.rawBody || (typeof payload === "string" ? payload : JSON.stringify(payload));
+      const hmac = import_node_crypto.default.createHmac("sha256", options.secret);
+      const bodyBuffer = typeof body === "string" ? Buffer.from(body) : body;
+      hmac.update(bodyBuffer);
+      const computedSignature = hmac.digest("hex");
+      return import_node_crypto.default.timingSafeEqual(Buffer.from(options.signature), Buffer.from(computedSignature));
+    } catch (error) {
+      return false;
+    }
+  }
+};
+function createAssemblyAIWebhookHandler() {
+  return new AssemblyAIWebhookHandler();
+}
+
+// src/webhooks/deepgram-webhook.ts
+var DeepgramWebhookHandler = class extends BaseWebhookHandler {
+  constructor() {
+    super(...arguments);
+    this.provider = "deepgram";
+  }
+  /**
+   * Check if payload matches Deepgram webhook format
+   */
+  matches(payload, _options) {
+    if (!payload || typeof payload !== "object") {
+      return false;
+    }
+    const obj = payload;
+    if (!("metadata" in obj) || !("results" in obj)) {
+      return false;
+    }
+    if (!obj.metadata || typeof obj.metadata !== "object") {
+      return false;
+    }
+    const metadata = obj.metadata;
+    if (!("request_id" in metadata)) {
+      return false;
+    }
+    if (!obj.results || typeof obj.results !== "object") {
+      return false;
+    }
+    const results = obj.results;
+    return "channels" in results;
+  }
+  /**
+   * Parse Deepgram webhook payload to unified format
+   */
+  parse(payload, _options) {
+    if (!this.matches(payload)) {
+      return this.createErrorEvent(payload, "Invalid Deepgram webhook payload");
+    }
+    const response = payload;
+    try {
+      const requestId = response.metadata.request_id;
+      const duration = response.metadata.duration;
+      const channels = response.results.channels || [];
+      if (channels.length === 0) {
+        return {
+          success: false,
+          provider: this.provider,
+          eventType: "transcription.failed",
+          data: {
+            id: requestId || "",
+            status: "error",
+            error: "No channels in response"
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          raw: payload
+        };
+      }
+      const channel = channels[0];
+      const alternatives = channel.alternatives || [];
+      if (alternatives.length === 0) {
+        return {
+          success: false,
+          provider: this.provider,
+          eventType: "transcription.failed",
+          data: {
+            id: requestId || "",
+            status: "error",
+            error: "No alternatives in response"
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          raw: payload
+        };
+      }
+      const alternative = alternatives[0];
+      const transcript = alternative.transcript;
+      if (!transcript) {
+        return {
+          success: false,
+          provider: this.provider,
+          eventType: "transcription.failed",
+          data: {
+            id: requestId || "",
+            status: "error",
+            error: "Empty transcript"
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          raw: payload
+        };
+      }
+      const words = alternative.words && alternative.words.length > 0 ? alternative.words.map((word) => ({
+        text: word.word || "",
+        start: word.start || 0,
+        end: word.end || 0,
+        confidence: word.confidence
+      })) : void 0;
+      const speakers = response.results.utterances && response.results.utterances.length > 0 ? response.results.utterances.map((utterance) => ({
+        id: utterance.speaker?.toString() || "unknown",
+        speaker: utterance.speaker?.toString() || "unknown",
+        text: utterance.transcript || "",
+        confidence: utterance.confidence
+      })) : void 0;
+      const utterances = response.results.utterances && response.results.utterances.length > 0 ? response.results.utterances.map((utterance) => ({
+        text: utterance.transcript || "",
+        start: utterance.start || 0,
+        end: utterance.end || 0,
+        speaker: utterance.speaker?.toString(),
+        confidence: utterance.confidence,
+        words: utterance.words && utterance.words.length > 0 ? utterance.words.map((word) => ({
+          text: word.word || "",
+          start: word.start || 0,
+          end: word.end || 0,
+          confidence: word.confidence
+        })) : void 0
+      })) : void 0;
+      const summary = alternative.summaries?.[0]?.summary;
+      return {
+        success: true,
+        provider: this.provider,
+        eventType: "transcription.completed",
+        data: {
+          id: requestId || "",
+          status: "completed",
+          text: transcript,
+          confidence: alternative.confidence,
+          duration,
+          language: response.metadata.models?.[0] || void 0,
+          speakers: speakers && speakers.length > 0 ? speakers : void 0,
+          words: words && words.length > 0 ? words : void 0,
+          utterances: utterances && utterances.length > 0 ? utterances : void 0,
+          summary,
+          metadata: {
+            channels: response.metadata.channels,
+            created: response.metadata.created,
+            models: response.metadata.models
+          }
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        raw: payload
+      };
+    } catch (error) {
+      return this.createErrorEvent(
+        payload,
+        `Failed to parse Deepgram webhook: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Verify Deepgram webhook signature
+   *
+   * Note: Deepgram does not currently support webhook signature verification.
+   * For security, use HTTPS and validate the request source (IP allowlist, etc.).
+   *
+   * @returns Always returns true (no verification available)
+   */
+  verify() {
+    return true;
+  }
+};
+function createDeepgramWebhookHandler() {
+  return new DeepgramWebhookHandler();
+}
+
+// src/webhooks/azure-webhook.ts
+var import_node_crypto2 = __toESM(require("crypto"));
+var AzureWebhookHandler = class extends BaseWebhookHandler {
+  constructor() {
+    super(...arguments);
+    this.provider = "azure-stt";
+  }
+  /**
+   * Check if payload matches Azure webhook format
+   */
+  matches(payload, _options) {
+    if (!payload || typeof payload !== "object") {
+      return false;
+    }
+    const obj = payload;
+    if (!("action" in obj) || !("timestamp" in obj)) {
+      return false;
+    }
+    if (typeof obj.action !== "string") {
+      return false;
+    }
+    if (!obj.action.startsWith("Transcription")) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Parse Azure webhook payload to unified format
+   */
+  parse(payload, _options) {
+    if (!this.matches(payload)) {
+      return this.createErrorEvent(payload, "Invalid Azure webhook payload");
+    }
+    const webhookPayload = payload;
+    const action = webhookPayload.action;
+    const timestamp = webhookPayload.timestamp;
+    let transcriptionId = "";
+    if (webhookPayload.self) {
+      const match = webhookPayload.self.match(/\/transcriptions\/([^/?]+)/);
+      if (match) {
+        transcriptionId = match[1];
+      }
+    }
+    if (action === "TranscriptionCreated") {
+      return {
+        success: true,
+        provider: this.provider,
+        eventType: "transcription.created",
+        data: {
+          id: transcriptionId,
+          status: "queued",
+          createdAt: timestamp
+        },
+        timestamp,
+        raw: payload
+      };
+    }
+    if (action === "TranscriptionRunning") {
+      return {
+        success: true,
+        provider: this.provider,
+        eventType: "transcription.processing",
+        data: {
+          id: transcriptionId,
+          status: "processing"
+        },
+        timestamp,
+        raw: payload
+      };
+    }
+    if (action === "TranscriptionSucceeded") {
+      return {
+        success: true,
+        provider: this.provider,
+        eventType: "transcription.completed",
+        data: {
+          id: transcriptionId,
+          status: "completed",
+          completedAt: timestamp
+          // Note: Full transcript data needs to be fetched via API
+          // using AzureAdapter.getTranscript(transcriptionId)
+        },
+        timestamp,
+        raw: payload
+      };
+    }
+    if (action === "TranscriptionFailed") {
+      return {
+        success: false,
+        provider: this.provider,
+        eventType: "transcription.failed",
+        data: {
+          id: transcriptionId,
+          status: "error",
+          error: webhookPayload.error?.message || "Transcription failed",
+          metadata: {
+            errorCode: webhookPayload.error?.code
+          }
+        },
+        timestamp,
+        raw: payload
+      };
+    }
+    return this.createErrorEvent(payload, `Unknown Azure webhook action: ${action}`);
+  }
+  /**
+   * Verify Azure webhook signature
+   *
+   * Azure can optionally sign webhooks using HMAC-SHA256.
+   * The signature is sent in the X-Azure-Signature header.
+   *
+   * Note: Signature verification is optional in Azure and must be
+   * configured when creating the webhook.
+   *
+   * @param payload - Webhook payload
+   * @param options - Verification options with signature and secret
+   * @returns true if signature is valid or no signature provided
+   *
+   * @example
+   * ```typescript
+   * const isValid = handler.verify(req.body, {
+   *   signature: req.headers['x-azure-signature'],
+   *   secret: process.env.AZURE_WEBHOOK_SECRET,
+   *   rawBody: req.rawBody
+   * });
+   * ```
+   */
+  verify(payload, options) {
+    if (!options.signature) {
+      return true;
+    }
+    if (!options.secret) {
+      return false;
+    }
+    try {
+      const body = options.rawBody || (typeof payload === "string" ? payload : JSON.stringify(payload));
+      const hmac = import_node_crypto2.default.createHmac("sha256", options.secret);
+      const bodyBuffer = typeof body === "string" ? Buffer.from(body) : body;
+      hmac.update(bodyBuffer);
+      const computedSignature = hmac.digest("hex");
+      return import_node_crypto2.default.timingSafeEqual(Buffer.from(options.signature), Buffer.from(computedSignature));
+    } catch (error) {
+      return false;
+    }
+  }
+};
+function createAzureWebhookHandler() {
+  return new AzureWebhookHandler();
+}
+
+// src/webhooks/speechmatics-webhook.ts
+var SpeechmaticsWebhookHandler = class extends BaseWebhookHandler {
+  constructor() {
+    super(...arguments);
+    this.provider = "speechmatics";
+  }
+  /**
+   * Check if payload matches Speechmatics webhook format
+   */
+  matches(payload, options) {
+    if (options?.userAgent) {
+      if (!options.userAgent.includes("Speechmatics-API")) {
+        return false;
+      }
+    }
+    if (options?.queryParams) {
+      const { id, status } = options.queryParams;
+      if (!id || !status) {
+        return false;
+      }
+    }
+    if (payload && typeof payload === "object") {
+      const obj = payload;
+      if ("format" in obj && "job" in obj && "metadata" in obj) {
+        return true;
+      }
+      if ("job" in obj || "id" in obj) {
+        return true;
+      }
+    }
+    return !!options?.queryParams?.id && !!options?.queryParams?.status;
+  }
+  /**
+   * Validate webhook request
+   */
+  validate(payload, options) {
+    if (!options?.queryParams?.id) {
+      return {
+        valid: false,
+        error: "Missing required query parameter: id"
+      };
+    }
+    if (!options?.queryParams?.status) {
+      return {
+        valid: false,
+        error: "Missing required query parameter: status"
+      };
+    }
+    const validStatuses = ["success", "error", "fetch_error", "trim_error"];
+    if (!validStatuses.includes(options.queryParams.status)) {
+      return {
+        valid: false,
+        error: `Invalid status value: ${options.queryParams.status}`
+      };
+    }
+    if (options?.userAgent && !options.userAgent.includes("Speechmatics-API")) {
+      return {
+        valid: false,
+        error: "Invalid user agent (expected Speechmatics-API/2.0)"
+      };
+    }
+    return { valid: true };
+  }
+  /**
+   * Parse webhook payload into unified event format
+   */
+  parse(payload, options) {
+    const queryParams = options?.queryParams || {};
+    const jobId = queryParams.id;
+    const status = queryParams.status;
+    let eventType;
+    if (status === "success") {
+      eventType = "transcription.completed";
+    } else if (status === "error" || status === "fetch_error" || status === "trim_error") {
+      eventType = "transcription.failed";
+    } else {
+      eventType = "transcription.created";
+    }
+    if (status === "success" && payload && typeof payload === "object") {
+      const transcript = payload;
+      if (transcript.results && transcript.job) {
+        const text = transcript.results.filter((r) => r.type === "word").map((r) => r.alternatives[0]?.content || "").join(" ");
+        const speakerSet = /* @__PURE__ */ new Set();
+        transcript.results.forEach((r) => {
+          const speaker = r.alternatives[0]?.speaker;
+          if (speaker) speakerSet.add(speaker);
+        });
+        const speakers = speakerSet.size > 0 ? Array.from(speakerSet).map((id) => ({
+          id,
+          label: `Speaker ${id}`
+        })) : void 0;
+        return {
+          success: true,
+          provider: this.provider,
+          eventType,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {
+            id: jobId,
+            text,
+            status: "completed",
+            language: transcript.metadata.transcription_config.language,
+            duration: transcript.job.duration,
+            speakers,
+            createdAt: transcript.job.created_at
+          },
+          raw: payload
+        };
+      }
+    }
+    return {
+      success: status === "success",
+      provider: this.provider,
+      eventType,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: {
+        id: jobId,
+        text: "",
+        status: status === "success" ? "completed" : "error"
+      },
+      raw: payload
+    };
+  }
+};
+
+// src/webhooks/webhook-router.ts
+var WebhookRouter = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map([
+      ["gladia", new GladiaWebhookHandler()],
+      ["assemblyai", new AssemblyAIWebhookHandler()],
+      ["deepgram", new DeepgramWebhookHandler()],
+      ["azure-stt", new AzureWebhookHandler()],
+      ["speechmatics", new SpeechmaticsWebhookHandler()]
+    ]);
+  }
+  /**
+   * Route webhook payload to the correct handler
+   *
+   * @param payload - Raw webhook payload
+   * @param options - Routing options (provider, verification, etc.)
+   * @returns Routing result with parsed event
+   */
+  route(payload, options) {
+    if (options?.provider) {
+      return this.routeToProvider(payload, options.provider, options);
+    }
+    const detectedProvider = this.detectProvider(payload, {
+      queryParams: options?.queryParams,
+      userAgent: options?.userAgent
+    });
+    if (!detectedProvider) {
+      return {
+        success: false,
+        error: "Could not detect webhook provider from payload structure"
+      };
+    }
+    return this.routeToProvider(payload, detectedProvider, options);
+  }
+  /**
+   * Detect provider from webhook payload structure
+   *
+   * @param payload - Raw webhook payload
+   * @param options - Detection options (query params, user agent, etc.)
+   * @returns Detected provider or undefined
+   */
+  detectProvider(payload, options) {
+    for (const [provider, handler] of this.handlers) {
+      if (handler.matches(payload, options)) {
+        return provider;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Validate webhook payload
+   *
+   * @param payload - Raw webhook payload
+   * @param options - Routing options
+   * @returns Validation result
+   */
+  validate(payload, options) {
+    if (options?.provider) {
+      const handler2 = this.handlers.get(options.provider);
+      if (!handler2) {
+        return {
+          valid: false,
+          error: `Unknown provider: ${options.provider}`
+        };
+      }
+      return handler2.validate(payload, {
+        queryParams: options.queryParams,
+        userAgent: options.userAgent
+      });
+    }
+    const detectedProvider = this.detectProvider(payload, {
+      queryParams: options?.queryParams,
+      userAgent: options?.userAgent
+    });
+    if (!detectedProvider) {
+      return {
+        valid: false,
+        error: "Could not detect webhook provider from payload structure"
+      };
+    }
+    const handler = this.handlers.get(detectedProvider);
+    if (!handler) {
+      return {
+        valid: false,
+        error: `Handler not found for provider: ${detectedProvider}`
+      };
+    }
+    return handler.validate(payload, {
+      queryParams: options?.queryParams,
+      userAgent: options?.userAgent
+    });
+  }
+  /**
+   * Verify webhook signature
+   *
+   * @param payload - Raw webhook payload
+   * @param provider - Provider name
+   * @param options - Verification options
+   * @returns true if signature is valid
+   */
+  verify(payload, provider, options) {
+    const handler = this.handlers.get(provider);
+    if (!handler || !handler.verify) {
+      return true;
+    }
+    return handler.verify(payload, options);
+  }
+  /**
+   * Route to a specific provider handler
+   */
+  routeToProvider(payload, provider, options) {
+    const handler = this.handlers.get(provider);
+    if (!handler) {
+      return {
+        success: false,
+        error: `Handler not found for provider: ${provider}`
+      };
+    }
+    let verified = true;
+    if (options?.verifySignature !== false && options?.verification && handler.verify) {
+      verified = handler.verify(payload, options.verification);
+      if (!verified) {
+        return {
+          success: false,
+          provider,
+          error: "Webhook signature verification failed",
+          verified: false
+        };
+      }
+    }
+    const validation = handler.validate(payload, {
+      queryParams: options?.queryParams,
+      userAgent: options?.userAgent
+    });
+    if (!validation.valid) {
+      return {
+        success: false,
+        provider,
+        error: validation.error,
+        verified
+      };
+    }
+    try {
+      const event = handler.parse(payload, {
+        queryParams: options?.queryParams
+      });
+      return {
+        success: true,
+        provider,
+        event,
+        verified
+      };
+    } catch (error) {
+      return {
+        success: false,
+        provider,
+        error: `Failed to parse webhook: ${error instanceof Error ? error.message : "Unknown error"}`,
+        verified
+      };
+    }
+  }
+  /**
+   * Get handler for a specific provider
+   *
+   * @param provider - Provider name
+   * @returns Handler instance or undefined
+   */
+  getHandler(provider) {
+    return this.handlers.get(provider);
+  }
+  /**
+   * Get all registered providers
+   *
+   * @returns Array of provider names
+   */
+  getProviders() {
+    return Array.from(this.handlers.keys());
+  }
+};
+function createWebhookRouter() {
+  return new WebhookRouter();
+}
+
+// src/generated/gladia/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  AudioChunkAckMessageType: () => AudioChunkAckMessageType,
+  AudioChunkActionType: () => AudioChunkActionType,
+  AudioToTextControllerAudioTranscriptionBodyLanguage: () => AudioToTextControllerAudioTranscriptionBodyLanguage,
+  AudioToTextControllerAudioTranscriptionBodyLanguageBehaviour: () => AudioToTextControllerAudioTranscriptionBodyLanguageBehaviour,
+  AudioToTextControllerAudioTranscriptionBodyOutputFormat: () => AudioToTextControllerAudioTranscriptionBodyOutputFormat,
+  AudioToTextControllerAudioTranscriptionBodyTargetTranslationLanguage: () => AudioToTextControllerAudioTranscriptionBodyTargetTranslationLanguage,
+  CallbackLiveAudioChunkAckMessageEvent: () => CallbackLiveAudioChunkAckMessageEvent,
+  CallbackLiveEndRecordingMessageEvent: () => CallbackLiveEndRecordingMessageEvent,
+  CallbackLiveEndSessionMessageEvent: () => CallbackLiveEndSessionMessageEvent,
+  CallbackLiveNamedEntityRecognitionMessageEvent: () => CallbackLiveNamedEntityRecognitionMessageEvent,
+  CallbackLivePostChapterizationMessageEvent: () => CallbackLivePostChapterizationMessageEvent,
+  CallbackLivePostFinalTranscriptMessageEvent: () => CallbackLivePostFinalTranscriptMessageEvent,
+  CallbackLivePostSummarizationMessageEvent: () => CallbackLivePostSummarizationMessageEvent,
+  CallbackLivePostTranscriptMessageEvent: () => CallbackLivePostTranscriptMessageEvent,
+  CallbackLiveSentimentAnalysisMessageEvent: () => CallbackLiveSentimentAnalysisMessageEvent,
+  CallbackLiveSpeechEndMessageEvent: () => CallbackLiveSpeechEndMessageEvent,
+  CallbackLiveSpeechStartMessageEvent: () => CallbackLiveSpeechStartMessageEvent,
+  CallbackLiveStartRecordingMessageEvent: () => CallbackLiveStartRecordingMessageEvent,
+  CallbackLiveStartSessionMessageEvent: () => CallbackLiveStartSessionMessageEvent,
+  CallbackLiveStopRecordingAckMessageEvent: () => CallbackLiveStopRecordingAckMessageEvent,
+  CallbackLiveTranscriptMessageEvent: () => CallbackLiveTranscriptMessageEvent,
+  CallbackLiveTranslationMessageEvent: () => CallbackLiveTranslationMessageEvent,
+  CallbackMethodEnum: () => CallbackMethodEnum,
+  CallbackTranscriptionErrorPayloadEvent: () => CallbackTranscriptionErrorPayloadEvent,
+  CallbackTranscriptionSuccessPayloadEvent: () => CallbackTranscriptionSuccessPayloadEvent,
+  EndRecordingMessageType: () => EndRecordingMessageType,
+  EndSessionMessageType: () => EndSessionMessageType,
+  HistoryControllerGetListV1KindItem: () => HistoryControllerGetListV1KindItem,
+  HistoryControllerGetListV1StatusItem: () => HistoryControllerGetListV1StatusItem,
+  NamedEntityRecognitionMessageType: () => NamedEntityRecognitionMessageType,
+  PostChapterizationMessageType: () => PostChapterizationMessageType,
+  PostFinalTranscriptMessageType: () => PostFinalTranscriptMessageType,
+  PostSummarizationMessageType: () => PostSummarizationMessageType,
+  PostTranscriptMessageType: () => PostTranscriptMessageType,
+  PreRecordedControllerGetPreRecordedJobsV2StatusItem: () => PreRecordedControllerGetPreRecordedJobsV2StatusItem,
+  PreRecordedResponseKind: () => PreRecordedResponseKind,
+  PreRecordedResponseStatus: () => PreRecordedResponseStatus,
+  SentimentAnalysisMessageType: () => SentimentAnalysisMessageType,
+  SpeechEndMessageType: () => SpeechEndMessageType,
+  SpeechStartMessageType: () => SpeechStartMessageType,
+  StartRecordingMessageType: () => StartRecordingMessageType,
+  StartSessionMessageType: () => StartSessionMessageType,
+  StopRecordingAckMessageType: () => StopRecordingAckMessageType,
+  StopRecordingActionType: () => StopRecordingActionType,
+  StreamingControllerGetStreamingJobsV2StatusItem: () => StreamingControllerGetStreamingJobsV2StatusItem,
+  StreamingResponseKind: () => StreamingResponseKind,
+  StreamingResponseStatus: () => StreamingResponseStatus,
+  StreamingSupportedBitDepthEnum: () => StreamingSupportedBitDepthEnum,
+  StreamingSupportedEncodingEnum: () => StreamingSupportedEncodingEnum,
+  StreamingSupportedModels: () => StreamingSupportedModels,
+  StreamingSupportedRegions: () => StreamingSupportedRegions,
+  StreamingSupportedSampleRateEnum: () => StreamingSupportedSampleRateEnum,
+  SubtitlesFormatEnum: () => SubtitlesFormatEnum,
+  SubtitlesStyleEnum: () => SubtitlesStyleEnum,
+  SummaryTypesEnum: () => SummaryTypesEnum,
+  TranscriptMessageType: () => TranscriptMessageType,
+  TranscriptionControllerListV2KindItem: () => TranscriptionControllerListV2KindItem,
+  TranscriptionControllerListV2StatusItem: () => TranscriptionControllerListV2StatusItem,
+  TranscriptionLanguageCodeEnum: () => TranscriptionLanguageCodeEnum,
+  TranslationLanguageCodeEnum: () => TranslationLanguageCodeEnum,
+  TranslationMessageType: () => TranslationMessageType,
+  TranslationModelEnum: () => TranslationModelEnum,
+  VideoToTextControllerVideoTranscriptionBodyLanguage: () => VideoToTextControllerVideoTranscriptionBodyLanguage,
+  VideoToTextControllerVideoTranscriptionBodyLanguageBehaviour: () => VideoToTextControllerVideoTranscriptionBodyLanguageBehaviour,
+  VideoToTextControllerVideoTranscriptionBodyOutputFormat: () => VideoToTextControllerVideoTranscriptionBodyOutputFormat,
+  VideoToTextControllerVideoTranscriptionBodyTargetTranslationLanguage: () => VideoToTextControllerVideoTranscriptionBodyTargetTranslationLanguage,
+  WebhookLiveEndRecordingPayloadEvent: () => WebhookLiveEndRecordingPayloadEvent,
+  WebhookLiveEndSessionPayloadEvent: () => WebhookLiveEndSessionPayloadEvent,
+  WebhookLiveStartRecordingPayloadEvent: () => WebhookLiveStartRecordingPayloadEvent,
+  WebhookLiveStartSessionPayloadEvent: () => WebhookLiveStartSessionPayloadEvent,
+  WebhookTranscriptionCreatedPayloadEvent: () => WebhookTranscriptionCreatedPayloadEvent,
+  WebhookTranscriptionErrorPayloadEvent: () => WebhookTranscriptionErrorPayloadEvent,
+  WebhookTranscriptionSuccessPayloadEvent: () => WebhookTranscriptionSuccessPayloadEvent
+});
+
+// src/generated/gladia/schema/audioChunkAckMessageType.ts
+var AudioChunkAckMessageType = {
+  audio_chunk: "audio_chunk"
+};
+
+// src/generated/gladia/schema/audioChunkActionType.ts
+var AudioChunkActionType = {
+  audio_chunk: "audio_chunk"
+};
+
+// src/generated/gladia/schema/audioToTextControllerAudioTranscriptionBodyLanguage.ts
+var AudioToTextControllerAudioTranscriptionBodyLanguage = {
+  afrikaans: "afrikaans",
+  albanian: "albanian",
+  amharic: "amharic",
+  arabic: "arabic",
+  armenian: "armenian",
+  assamese: "assamese",
+  azerbaijani: "azerbaijani",
+  bashkir: "bashkir",
+  basque: "basque",
+  belarusian: "belarusian",
+  bengali: "bengali",
+  bosnian: "bosnian",
+  breton: "breton",
+  bulgarian: "bulgarian",
+  catalan: "catalan",
+  chinese: "chinese",
+  croatian: "croatian",
+  czech: "czech",
+  danish: "danish",
+  dutch: "dutch",
+  english: "english",
+  estonian: "estonian",
+  faroese: "faroese",
+  finnish: "finnish",
+  french: "french",
+  galician: "galician",
+  georgian: "georgian",
+  german: "german",
+  greek: "greek",
+  gujarati: "gujarati",
+  haitian_creole: "haitian creole",
+  hausa: "hausa",
+  hawaiian: "hawaiian",
+  hebrew: "hebrew",
+  hindi: "hindi",
+  hungarian: "hungarian",
+  icelandic: "icelandic",
+  indonesian: "indonesian",
+  italian: "italian",
+  japanese: "japanese",
+  javanese: "javanese",
+  kannada: "kannada",
+  kazakh: "kazakh",
+  khmer: "khmer",
+  korean: "korean",
+  lao: "lao",
+  latin: "latin",
+  latvian: "latvian",
+  lingala: "lingala",
+  lithuanian: "lithuanian",
+  luxembourgish: "luxembourgish",
+  macedonian: "macedonian",
+  malagasy: "malagasy",
+  malay: "malay",
+  malayalam: "malayalam",
+  maltese: "maltese",
+  maori: "maori",
+  marathi: "marathi",
+  mongolian: "mongolian",
+  myanmar: "myanmar",
+  nepali: "nepali",
+  norwegian: "norwegian",
+  nynorsk: "nynorsk",
+  occitan: "occitan",
+  pashto: "pashto",
+  persian: "persian",
+  polish: "polish",
+  portuguese: "portuguese",
+  punjabi: "punjabi",
+  romanian: "romanian",
+  russian: "russian",
+  sanskrit: "sanskrit",
+  serbian: "serbian",
+  shona: "shona",
+  sindhi: "sindhi",
+  sinhala: "sinhala",
+  slovak: "slovak",
+  slovenian: "slovenian",
+  somali: "somali",
+  spanish: "spanish",
+  sundanese: "sundanese",
+  swahili: "swahili",
+  swedish: "swedish",
+  tagalog: "tagalog",
+  tajik: "tajik",
+  tamil: "tamil",
+  tatar: "tatar",
+  telugu: "telugu",
+  thai: "thai",
+  tibetan: "tibetan",
+  turkish: "turkish",
+  turkmen: "turkmen",
+  ukrainian: "ukrainian",
+  urdu: "urdu",
+  uzbek: "uzbek",
+  vietnamese: "vietnamese",
+  welsh: "welsh",
+  yiddish: "yiddish",
+  yoruba: "yoruba"
+};
+
+// src/generated/gladia/schema/audioToTextControllerAudioTranscriptionBodyLanguageBehaviour.ts
+var AudioToTextControllerAudioTranscriptionBodyLanguageBehaviour = {
+  automatic_single_language: "automatic single language",
+  automatic_multiple_languages: "automatic multiple languages",
+  manual: "manual"
+};
+
+// src/generated/gladia/schema/audioToTextControllerAudioTranscriptionBodyOutputFormat.ts
+var AudioToTextControllerAudioTranscriptionBodyOutputFormat = {
+  json: "json",
+  srt: "srt",
+  vtt: "vtt",
+  plain: "plain",
+  txt: "txt"
+};
+
+// src/generated/gladia/schema/audioToTextControllerAudioTranscriptionBodyTargetTranslationLanguage.ts
+var AudioToTextControllerAudioTranscriptionBodyTargetTranslationLanguage = {
+  afrikaans: "afrikaans",
+  albanian: "albanian",
+  amharic: "amharic",
+  arabic: "arabic",
+  armenian: "armenian",
+  assamese: "assamese",
+  azerbaijani: "azerbaijani",
+  bashkir: "bashkir",
+  basque: "basque",
+  belarusian: "belarusian",
+  bengali: "bengali",
+  bosnian: "bosnian",
+  breton: "breton",
+  bulgarian: "bulgarian",
+  catalan: "catalan",
+  chinese: "chinese",
+  croatian: "croatian",
+  czech: "czech",
+  danish: "danish",
+  dutch: "dutch",
+  english: "english",
+  estonian: "estonian",
+  faroese: "faroese",
+  finnish: "finnish",
+  french: "french",
+  galician: "galician",
+  georgian: "georgian",
+  german: "german",
+  greek: "greek",
+  gujarati: "gujarati",
+  haitian_creole: "haitian creole",
+  hausa: "hausa",
+  hawaiian: "hawaiian",
+  hebrew: "hebrew",
+  hindi: "hindi",
+  hungarian: "hungarian",
+  icelandic: "icelandic",
+  indonesian: "indonesian",
+  italian: "italian",
+  japanese: "japanese",
+  javanese: "javanese",
+  kannada: "kannada",
+  kazakh: "kazakh",
+  khmer: "khmer",
+  korean: "korean",
+  lao: "lao",
+  latin: "latin",
+  latvian: "latvian",
+  lingala: "lingala",
+  lithuanian: "lithuanian",
+  luxembourgish: "luxembourgish",
+  macedonian: "macedonian",
+  malagasy: "malagasy",
+  malay: "malay",
+  malayalam: "malayalam",
+  maltese: "maltese",
+  maori: "maori",
+  marathi: "marathi",
+  mongolian: "mongolian",
+  myanmar: "myanmar",
+  nepali: "nepali",
+  norwegian: "norwegian",
+  nynorsk: "nynorsk",
+  occitan: "occitan",
+  pashto: "pashto",
+  persian: "persian",
+  polish: "polish",
+  portuguese: "portuguese",
+  punjabi: "punjabi",
+  romanian: "romanian",
+  russian: "russian",
+  sanskrit: "sanskrit",
+  serbian: "serbian",
+  shona: "shona",
+  sindhi: "sindhi",
+  sinhala: "sinhala",
+  slovak: "slovak",
+  slovenian: "slovenian",
+  somali: "somali",
+  spanish: "spanish",
+  sundanese: "sundanese",
+  swahili: "swahili",
+  swedish: "swedish",
+  tagalog: "tagalog",
+  tajik: "tajik",
+  tamil: "tamil",
+  tatar: "tatar",
+  telugu: "telugu",
+  thai: "thai",
+  tibetan: "tibetan",
+  turkish: "turkish",
+  turkmen: "turkmen",
+  ukrainian: "ukrainian",
+  urdu: "urdu",
+  uzbek: "uzbek",
+  vietnamese: "vietnamese",
+  welsh: "welsh",
+  wolof: "wolof",
+  yiddish: "yiddish",
+  yoruba: "yoruba"
+};
+
+// src/generated/gladia/schema/callbackLiveAudioChunkAckMessageEvent.ts
+var CallbackLiveAudioChunkAckMessageEvent = {
+  liveaudio_chunk: "live.audio_chunk"
+};
+
+// src/generated/gladia/schema/callbackLiveEndRecordingMessageEvent.ts
+var CallbackLiveEndRecordingMessageEvent = {
+  liveend_recording: "live.end_recording"
+};
+
+// src/generated/gladia/schema/callbackLiveEndSessionMessageEvent.ts
+var CallbackLiveEndSessionMessageEvent = {
+  liveend_session: "live.end_session"
+};
+
+// src/generated/gladia/schema/callbackLiveNamedEntityRecognitionMessageEvent.ts
+var CallbackLiveNamedEntityRecognitionMessageEvent = {
+  livenamed_entity_recognition: "live.named_entity_recognition"
+};
+
+// src/generated/gladia/schema/callbackLivePostChapterizationMessageEvent.ts
+var CallbackLivePostChapterizationMessageEvent = {
+  livepost_chapterization: "live.post_chapterization"
+};
+
+// src/generated/gladia/schema/callbackLivePostFinalTranscriptMessageEvent.ts
+var CallbackLivePostFinalTranscriptMessageEvent = {
+  livepost_final_transcript: "live.post_final_transcript"
+};
+
+// src/generated/gladia/schema/callbackLivePostSummarizationMessageEvent.ts
+var CallbackLivePostSummarizationMessageEvent = {
+  livepost_summarization: "live.post_summarization"
+};
+
+// src/generated/gladia/schema/callbackLivePostTranscriptMessageEvent.ts
+var CallbackLivePostTranscriptMessageEvent = {
+  livepost_transcript: "live.post_transcript"
+};
+
+// src/generated/gladia/schema/callbackLiveSentimentAnalysisMessageEvent.ts
+var CallbackLiveSentimentAnalysisMessageEvent = {
+  livesentiment_analysis: "live.sentiment_analysis"
+};
+
+// src/generated/gladia/schema/callbackLiveSpeechEndMessageEvent.ts
+var CallbackLiveSpeechEndMessageEvent = {
+  livespeech_end: "live.speech_end"
+};
+
+// src/generated/gladia/schema/callbackLiveSpeechStartMessageEvent.ts
+var CallbackLiveSpeechStartMessageEvent = {
+  livespeech_start: "live.speech_start"
+};
+
+// src/generated/gladia/schema/callbackLiveStartRecordingMessageEvent.ts
+var CallbackLiveStartRecordingMessageEvent = {
+  livestart_recording: "live.start_recording"
+};
+
+// src/generated/gladia/schema/callbackLiveStartSessionMessageEvent.ts
+var CallbackLiveStartSessionMessageEvent = {
+  livestart_session: "live.start_session"
+};
+
+// src/generated/gladia/schema/callbackLiveStopRecordingAckMessageEvent.ts
+var CallbackLiveStopRecordingAckMessageEvent = {
+  livestop_recording: "live.stop_recording"
+};
+
+// src/generated/gladia/schema/callbackLiveTranscriptMessageEvent.ts
+var CallbackLiveTranscriptMessageEvent = {
+  livetranscript: "live.transcript"
+};
+
+// src/generated/gladia/schema/callbackLiveTranslationMessageEvent.ts
+var CallbackLiveTranslationMessageEvent = {
+  livetranslation: "live.translation"
+};
+
+// src/generated/gladia/schema/callbackMethodEnum.ts
+var CallbackMethodEnum = {
+  POST: "POST",
+  PUT: "PUT"
+};
+
+// src/generated/gladia/schema/callbackTranscriptionErrorPayloadEvent.ts
+var CallbackTranscriptionErrorPayloadEvent = {
+  transcriptionerror: "transcription.error"
+};
+
+// src/generated/gladia/schema/callbackTranscriptionSuccessPayloadEvent.ts
+var CallbackTranscriptionSuccessPayloadEvent = {
+  transcriptionsuccess: "transcription.success"
+};
+
+// src/generated/gladia/schema/endRecordingMessageType.ts
+var EndRecordingMessageType = {
+  end_recording: "end_recording"
+};
+
+// src/generated/gladia/schema/endSessionMessageType.ts
+var EndSessionMessageType = {
+  end_session: "end_session"
+};
+
+// src/generated/gladia/schema/historyControllerGetListV1KindItem.ts
+var HistoryControllerGetListV1KindItem = {
+  "pre-recorded": "pre-recorded",
+  live: "live"
+};
+
+// src/generated/gladia/schema/historyControllerGetListV1StatusItem.ts
+var HistoryControllerGetListV1StatusItem = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/namedEntityRecognitionMessageType.ts
+var NamedEntityRecognitionMessageType = {
+  named_entity_recognition: "named_entity_recognition"
+};
+
+// src/generated/gladia/schema/postChapterizationMessageType.ts
+var PostChapterizationMessageType = {
+  post_chapterization: "post_chapterization"
+};
+
+// src/generated/gladia/schema/postFinalTranscriptMessageType.ts
+var PostFinalTranscriptMessageType = {
+  post_final_transcript: "post_final_transcript"
+};
+
+// src/generated/gladia/schema/postSummarizationMessageType.ts
+var PostSummarizationMessageType = {
+  post_summarization: "post_summarization"
+};
+
+// src/generated/gladia/schema/postTranscriptMessageType.ts
+var PostTranscriptMessageType = {
+  post_transcript: "post_transcript"
+};
+
+// src/generated/gladia/schema/preRecordedControllerGetPreRecordedJobsV2StatusItem.ts
+var PreRecordedControllerGetPreRecordedJobsV2StatusItem = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/preRecordedResponseKind.ts
+var PreRecordedResponseKind = {
+  "pre-recorded": "pre-recorded"
+};
+
+// src/generated/gladia/schema/preRecordedResponseStatus.ts
+var PreRecordedResponseStatus = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/sentimentAnalysisMessageType.ts
+var SentimentAnalysisMessageType = {
+  sentiment_analysis: "sentiment_analysis"
+};
+
+// src/generated/gladia/schema/speechEndMessageType.ts
+var SpeechEndMessageType = {
+  speech_end: "speech_end"
+};
+
+// src/generated/gladia/schema/speechStartMessageType.ts
+var SpeechStartMessageType = {
+  speech_start: "speech_start"
+};
+
+// src/generated/gladia/schema/startRecordingMessageType.ts
+var StartRecordingMessageType = {
+  start_recording: "start_recording"
+};
+
+// src/generated/gladia/schema/startSessionMessageType.ts
+var StartSessionMessageType = {
+  start_session: "start_session"
+};
+
+// src/generated/gladia/schema/stopRecordingAckMessageType.ts
+var StopRecordingAckMessageType = {
+  stop_recording: "stop_recording"
+};
+
+// src/generated/gladia/schema/stopRecordingActionType.ts
+var StopRecordingActionType = {
+  stop_recording: "stop_recording"
+};
+
+// src/generated/gladia/schema/streamingControllerGetStreamingJobsV2StatusItem.ts
+var StreamingControllerGetStreamingJobsV2StatusItem = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/streamingResponseKind.ts
+var StreamingResponseKind = {
+  live: "live"
+};
+
+// src/generated/gladia/schema/streamingResponseStatus.ts
+var StreamingResponseStatus = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/streamingSupportedBitDepthEnum.ts
+var StreamingSupportedBitDepthEnum = {
+  NUMBER_8: 8,
+  NUMBER_16: 16,
+  NUMBER_24: 24,
+  NUMBER_32: 32
+};
+
+// src/generated/gladia/schema/streamingSupportedEncodingEnum.ts
+var StreamingSupportedEncodingEnum = {
+  "wav/pcm": "wav/pcm",
+  "wav/alaw": "wav/alaw",
+  "wav/ulaw": "wav/ulaw"
+};
+
+// src/generated/gladia/schema/streamingSupportedModels.ts
+var StreamingSupportedModels = {
+  "solaria-1": "solaria-1"
+};
+
+// src/generated/gladia/schema/streamingSupportedRegions.ts
+var StreamingSupportedRegions = {
+  "us-west": "us-west",
+  "eu-west": "eu-west"
+};
+
+// src/generated/gladia/schema/streamingSupportedSampleRateEnum.ts
+var StreamingSupportedSampleRateEnum = {
+  NUMBER_8000: 8e3,
+  NUMBER_16000: 16e3,
+  NUMBER_32000: 32e3,
+  NUMBER_44100: 44100,
+  NUMBER_48000: 48e3
+};
+
+// src/generated/gladia/schema/subtitlesFormatEnum.ts
+var SubtitlesFormatEnum = {
+  srt: "srt",
+  vtt: "vtt"
+};
+
+// src/generated/gladia/schema/subtitlesStyleEnum.ts
+var SubtitlesStyleEnum = {
+  default: "default",
+  compliance: "compliance"
+};
+
+// src/generated/gladia/schema/summaryTypesEnum.ts
+var SummaryTypesEnum = {
+  general: "general",
+  bullet_points: "bullet_points",
+  concise: "concise"
+};
+
+// src/generated/gladia/schema/transcriptMessageType.ts
+var TranscriptMessageType = {
+  transcript: "transcript"
+};
+
+// src/generated/gladia/schema/transcriptionControllerListV2KindItem.ts
+var TranscriptionControllerListV2KindItem = {
+  "pre-recorded": "pre-recorded",
+  live: "live"
+};
+
+// src/generated/gladia/schema/transcriptionControllerListV2StatusItem.ts
+var TranscriptionControllerListV2StatusItem = {
+  queued: "queued",
+  processing: "processing",
+  done: "done",
+  error: "error"
+};
+
+// src/generated/gladia/schema/transcriptionLanguageCodeEnum.ts
+var TranscriptionLanguageCodeEnum = {
+  af: "af",
+  am: "am",
+  ar: "ar",
+  as: "as",
+  az: "az",
+  ba: "ba",
+  be: "be",
+  bg: "bg",
+  bn: "bn",
+  bo: "bo",
+  br: "br",
+  bs: "bs",
+  ca: "ca",
+  cs: "cs",
+  cy: "cy",
+  da: "da",
+  de: "de",
+  el: "el",
+  en: "en",
+  es: "es",
+  et: "et",
+  eu: "eu",
+  fa: "fa",
+  fi: "fi",
+  fo: "fo",
+  fr: "fr",
+  gl: "gl",
+  gu: "gu",
+  ha: "ha",
+  haw: "haw",
+  he: "he",
+  hi: "hi",
+  hr: "hr",
+  ht: "ht",
+  hu: "hu",
+  hy: "hy",
+  id: "id",
+  is: "is",
+  it: "it",
+  ja: "ja",
+  jw: "jw",
+  ka: "ka",
+  kk: "kk",
+  km: "km",
+  kn: "kn",
+  ko: "ko",
+  la: "la",
+  lb: "lb",
+  ln: "ln",
+  lo: "lo",
+  lt: "lt",
+  lv: "lv",
+  mg: "mg",
+  mi: "mi",
+  mk: "mk",
+  ml: "ml",
+  mn: "mn",
+  mr: "mr",
+  ms: "ms",
+  mt: "mt",
+  my: "my",
+  ne: "ne",
+  nl: "nl",
+  nn: "nn",
+  no: "no",
+  oc: "oc",
+  pa: "pa",
+  pl: "pl",
+  ps: "ps",
+  pt: "pt",
+  ro: "ro",
+  ru: "ru",
+  sa: "sa",
+  sd: "sd",
+  si: "si",
+  sk: "sk",
+  sl: "sl",
+  sn: "sn",
+  so: "so",
+  sq: "sq",
+  sr: "sr",
+  su: "su",
+  sv: "sv",
+  sw: "sw",
+  ta: "ta",
+  te: "te",
+  tg: "tg",
+  th: "th",
+  tk: "tk",
+  tl: "tl",
+  tr: "tr",
+  tt: "tt",
+  uk: "uk",
+  ur: "ur",
+  uz: "uz",
+  vi: "vi",
+  yi: "yi",
+  yo: "yo",
+  zh: "zh"
+};
+
+// src/generated/gladia/schema/translationLanguageCodeEnum.ts
+var TranslationLanguageCodeEnum = {
+  af: "af",
+  am: "am",
+  ar: "ar",
+  as: "as",
+  az: "az",
+  ba: "ba",
+  be: "be",
+  bg: "bg",
+  bn: "bn",
+  bo: "bo",
+  br: "br",
+  bs: "bs",
+  ca: "ca",
+  cs: "cs",
+  cy: "cy",
+  da: "da",
+  de: "de",
+  el: "el",
+  en: "en",
+  es: "es",
+  et: "et",
+  eu: "eu",
+  fa: "fa",
+  fi: "fi",
+  fo: "fo",
+  fr: "fr",
+  gl: "gl",
+  gu: "gu",
+  ha: "ha",
+  haw: "haw",
+  he: "he",
+  hi: "hi",
+  hr: "hr",
+  ht: "ht",
+  hu: "hu",
+  hy: "hy",
+  id: "id",
+  is: "is",
+  it: "it",
+  ja: "ja",
+  jw: "jw",
+  ka: "ka",
+  kk: "kk",
+  km: "km",
+  kn: "kn",
+  ko: "ko",
+  la: "la",
+  lb: "lb",
+  ln: "ln",
+  lo: "lo",
+  lt: "lt",
+  lv: "lv",
+  mg: "mg",
+  mi: "mi",
+  mk: "mk",
+  ml: "ml",
+  mn: "mn",
+  mr: "mr",
+  ms: "ms",
+  mt: "mt",
+  my: "my",
+  ne: "ne",
+  nl: "nl",
+  nn: "nn",
+  no: "no",
+  oc: "oc",
+  pa: "pa",
+  pl: "pl",
+  ps: "ps",
+  pt: "pt",
+  ro: "ro",
+  ru: "ru",
+  sa: "sa",
+  sd: "sd",
+  si: "si",
+  sk: "sk",
+  sl: "sl",
+  sn: "sn",
+  so: "so",
+  sq: "sq",
+  sr: "sr",
+  su: "su",
+  sv: "sv",
+  sw: "sw",
+  ta: "ta",
+  te: "te",
+  tg: "tg",
+  th: "th",
+  tk: "tk",
+  tl: "tl",
+  tr: "tr",
+  tt: "tt",
+  uk: "uk",
+  ur: "ur",
+  uz: "uz",
+  vi: "vi",
+  wo: "wo",
+  yi: "yi",
+  yo: "yo",
+  zh: "zh"
+};
+
+// src/generated/gladia/schema/translationMessageType.ts
+var TranslationMessageType = {
+  translation: "translation"
+};
+
+// src/generated/gladia/schema/translationModelEnum.ts
+var TranslationModelEnum = {
+  base: "base",
+  enhanced: "enhanced"
+};
+
+// src/generated/gladia/schema/videoToTextControllerVideoTranscriptionBodyLanguage.ts
+var VideoToTextControllerVideoTranscriptionBodyLanguage = {
+  afrikaans: "afrikaans",
+  albanian: "albanian",
+  amharic: "amharic",
+  arabic: "arabic",
+  armenian: "armenian",
+  assamese: "assamese",
+  azerbaijani: "azerbaijani",
+  bashkir: "bashkir",
+  basque: "basque",
+  belarusian: "belarusian",
+  bengali: "bengali",
+  bosnian: "bosnian",
+  breton: "breton",
+  bulgarian: "bulgarian",
+  catalan: "catalan",
+  chinese: "chinese",
+  croatian: "croatian",
+  czech: "czech",
+  danish: "danish",
+  dutch: "dutch",
+  english: "english",
+  estonian: "estonian",
+  faroese: "faroese",
+  finnish: "finnish",
+  french: "french",
+  galician: "galician",
+  georgian: "georgian",
+  german: "german",
+  greek: "greek",
+  gujarati: "gujarati",
+  haitian_creole: "haitian creole",
+  hausa: "hausa",
+  hawaiian: "hawaiian",
+  hebrew: "hebrew",
+  hindi: "hindi",
+  hungarian: "hungarian",
+  icelandic: "icelandic",
+  indonesian: "indonesian",
+  italian: "italian",
+  japanese: "japanese",
+  javanese: "javanese",
+  kannada: "kannada",
+  kazakh: "kazakh",
+  khmer: "khmer",
+  korean: "korean",
+  lao: "lao",
+  latin: "latin",
+  latvian: "latvian",
+  lingala: "lingala",
+  lithuanian: "lithuanian",
+  luxembourgish: "luxembourgish",
+  macedonian: "macedonian",
+  malagasy: "malagasy",
+  malay: "malay",
+  malayalam: "malayalam",
+  maltese: "maltese",
+  maori: "maori",
+  marathi: "marathi",
+  mongolian: "mongolian",
+  myanmar: "myanmar",
+  nepali: "nepali",
+  norwegian: "norwegian",
+  nynorsk: "nynorsk",
+  occitan: "occitan",
+  pashto: "pashto",
+  persian: "persian",
+  polish: "polish",
+  portuguese: "portuguese",
+  punjabi: "punjabi",
+  romanian: "romanian",
+  russian: "russian",
+  sanskrit: "sanskrit",
+  serbian: "serbian",
+  shona: "shona",
+  sindhi: "sindhi",
+  sinhala: "sinhala",
+  slovak: "slovak",
+  slovenian: "slovenian",
+  somali: "somali",
+  spanish: "spanish",
+  sundanese: "sundanese",
+  swahili: "swahili",
+  swedish: "swedish",
+  tagalog: "tagalog",
+  tajik: "tajik",
+  tamil: "tamil",
+  tatar: "tatar",
+  telugu: "telugu",
+  thai: "thai",
+  tibetan: "tibetan",
+  turkish: "turkish",
+  turkmen: "turkmen",
+  ukrainian: "ukrainian",
+  urdu: "urdu",
+  uzbek: "uzbek",
+  vietnamese: "vietnamese",
+  welsh: "welsh",
+  yiddish: "yiddish",
+  yoruba: "yoruba"
+};
+
+// src/generated/gladia/schema/videoToTextControllerVideoTranscriptionBodyLanguageBehaviour.ts
+var VideoToTextControllerVideoTranscriptionBodyLanguageBehaviour = {
+  automatic_single_language: "automatic single language",
+  automatic_multiple_languages: "automatic multiple languages",
+  manual: "manual"
+};
+
+// src/generated/gladia/schema/videoToTextControllerVideoTranscriptionBodyOutputFormat.ts
+var VideoToTextControllerVideoTranscriptionBodyOutputFormat = {
+  json: "json",
+  srt: "srt",
+  vtt: "vtt",
+  plain: "plain",
+  txt: "txt"
+};
+
+// src/generated/gladia/schema/videoToTextControllerVideoTranscriptionBodyTargetTranslationLanguage.ts
+var VideoToTextControllerVideoTranscriptionBodyTargetTranslationLanguage = {
+  afrikaans: "afrikaans",
+  albanian: "albanian",
+  amharic: "amharic",
+  arabic: "arabic",
+  armenian: "armenian",
+  assamese: "assamese",
+  azerbaijani: "azerbaijani",
+  bashkir: "bashkir",
+  basque: "basque",
+  belarusian: "belarusian",
+  bengali: "bengali",
+  bosnian: "bosnian",
+  breton: "breton",
+  bulgarian: "bulgarian",
+  catalan: "catalan",
+  chinese: "chinese",
+  croatian: "croatian",
+  czech: "czech",
+  danish: "danish",
+  dutch: "dutch",
+  english: "english",
+  estonian: "estonian",
+  faroese: "faroese",
+  finnish: "finnish",
+  french: "french",
+  galician: "galician",
+  georgian: "georgian",
+  german: "german",
+  greek: "greek",
+  gujarati: "gujarati",
+  haitian_creole: "haitian creole",
+  hausa: "hausa",
+  hawaiian: "hawaiian",
+  hebrew: "hebrew",
+  hindi: "hindi",
+  hungarian: "hungarian",
+  icelandic: "icelandic",
+  indonesian: "indonesian",
+  italian: "italian",
+  japanese: "japanese",
+  javanese: "javanese",
+  kannada: "kannada",
+  kazakh: "kazakh",
+  khmer: "khmer",
+  korean: "korean",
+  lao: "lao",
+  latin: "latin",
+  latvian: "latvian",
+  lingala: "lingala",
+  lithuanian: "lithuanian",
+  luxembourgish: "luxembourgish",
+  macedonian: "macedonian",
+  malagasy: "malagasy",
+  malay: "malay",
+  malayalam: "malayalam",
+  maltese: "maltese",
+  maori: "maori",
+  marathi: "marathi",
+  mongolian: "mongolian",
+  myanmar: "myanmar",
+  nepali: "nepali",
+  norwegian: "norwegian",
+  nynorsk: "nynorsk",
+  occitan: "occitan",
+  pashto: "pashto",
+  persian: "persian",
+  polish: "polish",
+  portuguese: "portuguese",
+  punjabi: "punjabi",
+  romanian: "romanian",
+  russian: "russian",
+  sanskrit: "sanskrit",
+  serbian: "serbian",
+  shona: "shona",
+  sindhi: "sindhi",
+  sinhala: "sinhala",
+  slovak: "slovak",
+  slovenian: "slovenian",
+  somali: "somali",
+  spanish: "spanish",
+  sundanese: "sundanese",
+  swahili: "swahili",
+  swedish: "swedish",
+  tagalog: "tagalog",
+  tajik: "tajik",
+  tamil: "tamil",
+  tatar: "tatar",
+  telugu: "telugu",
+  thai: "thai",
+  tibetan: "tibetan",
+  turkish: "turkish",
+  turkmen: "turkmen",
+  ukrainian: "ukrainian",
+  urdu: "urdu",
+  uzbek: "uzbek",
+  vietnamese: "vietnamese",
+  welsh: "welsh",
+  wolof: "wolof",
+  yiddish: "yiddish",
+  yoruba: "yoruba"
+};
+
+// src/generated/gladia/schema/webhookLiveEndRecordingPayloadEvent.ts
+var WebhookLiveEndRecordingPayloadEvent = {
+  liveend_recording: "live.end_recording"
+};
+
+// src/generated/gladia/schema/webhookLiveEndSessionPayloadEvent.ts
+var WebhookLiveEndSessionPayloadEvent = {
+  liveend_session: "live.end_session"
+};
+
+// src/generated/gladia/schema/webhookLiveStartRecordingPayloadEvent.ts
+var WebhookLiveStartRecordingPayloadEvent = {
+  livestart_recording: "live.start_recording"
+};
+
+// src/generated/gladia/schema/webhookLiveStartSessionPayloadEvent.ts
+var WebhookLiveStartSessionPayloadEvent = {
+  livestart_session: "live.start_session"
+};
+
+// src/generated/gladia/schema/webhookTranscriptionCreatedPayloadEvent.ts
+var WebhookTranscriptionCreatedPayloadEvent = {
+  transcriptioncreated: "transcription.created"
+};
+
+// src/generated/gladia/schema/webhookTranscriptionErrorPayloadEvent.ts
+var WebhookTranscriptionErrorPayloadEvent = {
+  transcriptionerror: "transcription.error"
+};
+
+// src/generated/gladia/schema/webhookTranscriptionSuccessPayloadEvent.ts
+var WebhookTranscriptionSuccessPayloadEvent = {
+  transcriptionsuccess: "transcription.success"
+};
+
+// src/generated/assemblyai/schema/index.ts
+var schema_exports2 = {};
+__export(schema_exports2, {
+  AudioIntelligenceModelStatus: () => AudioIntelligenceModelStatus,
+  EntityType: () => EntityType,
+  LemurModel: () => LemurModel,
+  PiiPolicy: () => PiiPolicy,
+  RedactPiiAudioQuality: () => RedactPiiAudioQuality,
+  RedactedAudioStatus: () => RedactedAudioStatus,
+  Sentiment: () => Sentiment,
+  SpeechModel: () => SpeechModel,
+  SubstitutionPolicy: () => SubstitutionPolicy,
+  SubtitleFormat: () => SubtitleFormat,
+  SummaryModel: () => SummaryModel,
+  SummaryType: () => SummaryType,
+  TranscriptBoostParam: () => TranscriptBoostParam,
+  TranscriptLanguageCode: () => TranscriptLanguageCode,
+  TranscriptReadyStatus: () => TranscriptReadyStatus,
+  TranscriptStatus: () => TranscriptStatus
+});
+
+// src/generated/assemblyai/schema/audioIntelligenceModelStatus.ts
+var AudioIntelligenceModelStatus = {
+  success: "success",
+  unavailable: "unavailable"
+};
+
+// src/generated/assemblyai/schema/entityType.ts
+var EntityType = {
+  account_number: "account_number",
+  banking_information: "banking_information",
+  blood_type: "blood_type",
+  credit_card_cvv: "credit_card_cvv",
+  credit_card_expiration: "credit_card_expiration",
+  credit_card_number: "credit_card_number",
+  date: "date",
+  date_interval: "date_interval",
+  date_of_birth: "date_of_birth",
+  drivers_license: "drivers_license",
+  drug: "drug",
+  duration: "duration",
+  email_address: "email_address",
+  event: "event",
+  filename: "filename",
+  gender_sexuality: "gender_sexuality",
+  healthcare_number: "healthcare_number",
+  injury: "injury",
+  ip_address: "ip_address",
+  language: "language",
+  location: "location",
+  marital_status: "marital_status",
+  medical_condition: "medical_condition",
+  medical_process: "medical_process",
+  money_amount: "money_amount",
+  nationality: "nationality",
+  number_sequence: "number_sequence",
+  occupation: "occupation",
+  organization: "organization",
+  passport_number: "passport_number",
+  password: "password",
+  person_age: "person_age",
+  person_name: "person_name",
+  phone_number: "phone_number",
+  physical_attribute: "physical_attribute",
+  political_affiliation: "political_affiliation",
+  religion: "religion",
+  statistics: "statistics",
+  time: "time",
+  url: "url",
+  us_social_security_number: "us_social_security_number",
+  username: "username",
+  vehicle_id: "vehicle_id",
+  zodiac_sign: "zodiac_sign"
+};
+
+// src/generated/assemblyai/schema/lemurModel.ts
+var LemurModel = {
+  "anthropic/claude-3-5-sonnet": "anthropic/claude-3-5-sonnet",
+  "anthropic/claude-3-opus": "anthropic/claude-3-opus",
+  "anthropic/claude-3-haiku": "anthropic/claude-3-haiku"
+};
+
+// src/generated/assemblyai/schema/piiPolicy.ts
+var PiiPolicy = {
+  account_number: "account_number",
+  banking_information: "banking_information",
+  blood_type: "blood_type",
+  credit_card_cvv: "credit_card_cvv",
+  credit_card_expiration: "credit_card_expiration",
+  credit_card_number: "credit_card_number",
+  date: "date",
+  date_interval: "date_interval",
+  date_of_birth: "date_of_birth",
+  drivers_license: "drivers_license",
+  drug: "drug",
+  duration: "duration",
+  email_address: "email_address",
+  event: "event",
+  filename: "filename",
+  gender_sexuality: "gender_sexuality",
+  healthcare_number: "healthcare_number",
+  injury: "injury",
+  ip_address: "ip_address",
+  language: "language",
+  location: "location",
+  marital_status: "marital_status",
+  medical_condition: "medical_condition",
+  medical_process: "medical_process",
+  money_amount: "money_amount",
+  nationality: "nationality",
+  number_sequence: "number_sequence",
+  occupation: "occupation",
+  organization: "organization",
+  passport_number: "passport_number",
+  password: "password",
+  person_age: "person_age",
+  person_name: "person_name",
+  phone_number: "phone_number",
+  physical_attribute: "physical_attribute",
+  political_affiliation: "political_affiliation",
+  religion: "religion",
+  statistics: "statistics",
+  time: "time",
+  url: "url",
+  us_social_security_number: "us_social_security_number",
+  username: "username",
+  vehicle_id: "vehicle_id",
+  zodiac_sign: "zodiac_sign"
+};
+
+// src/generated/assemblyai/schema/redactPiiAudioQuality.ts
+var RedactPiiAudioQuality = {
+  mp3: "mp3",
+  wav: "wav"
+};
+
+// src/generated/assemblyai/schema/redactedAudioStatus.ts
+var RedactedAudioStatus = {
+  redacted_audio_ready: "redacted_audio_ready"
+};
+
+// src/generated/assemblyai/schema/sentiment.ts
+var Sentiment = {
+  POSITIVE: "POSITIVE",
+  NEUTRAL: "NEUTRAL",
+  NEGATIVE: "NEGATIVE"
+};
+
+// src/generated/assemblyai/schema/speechModel.ts
+var SpeechModel = {
+  best: "best",
+  "slam-1": "slam-1",
+  universal: "universal"
+};
+
+// src/generated/assemblyai/schema/substitutionPolicy.ts
+var SubstitutionPolicy = {
+  entity_name: "entity_name",
+  hash: "hash"
+};
+
+// src/generated/assemblyai/schema/subtitleFormat.ts
+var SubtitleFormat = {
+  srt: "srt",
+  vtt: "vtt"
+};
+
+// src/generated/assemblyai/schema/summaryModel.ts
+var SummaryModel = {
+  informative: "informative",
+  conversational: "conversational",
+  catchy: "catchy"
+};
+
+// src/generated/assemblyai/schema/summaryType.ts
+var SummaryType = {
+  bullets: "bullets",
+  bullets_verbose: "bullets_verbose",
+  gist: "gist",
+  headline: "headline",
+  paragraph: "paragraph"
+};
+
+// src/generated/assemblyai/schema/transcriptBoostParam.ts
+var TranscriptBoostParam = {
+  low: "low",
+  default: "default",
+  high: "high"
+};
+
+// src/generated/assemblyai/schema/transcriptLanguageCode.ts
+var TranscriptLanguageCode = {
+  en: "en",
+  en_au: "en_au",
+  en_uk: "en_uk",
+  en_us: "en_us",
+  es: "es",
+  fr: "fr",
+  de: "de",
+  it: "it",
+  pt: "pt",
+  nl: "nl",
+  af: "af",
+  sq: "sq",
+  am: "am",
+  ar: "ar",
+  hy: "hy",
+  as: "as",
+  az: "az",
+  ba: "ba",
+  eu: "eu",
+  be: "be",
+  bn: "bn",
+  bs: "bs",
+  br: "br",
+  bg: "bg",
+  my: "my",
+  ca: "ca",
+  zh: "zh",
+  hr: "hr",
+  cs: "cs",
+  da: "da",
+  et: "et",
+  fo: "fo",
+  fi: "fi",
+  gl: "gl",
+  ka: "ka",
+  el: "el",
+  gu: "gu",
+  ht: "ht",
+  ha: "ha",
+  haw: "haw",
+  he: "he",
+  hi: "hi",
+  hu: "hu",
+  is: "is",
+  id: "id",
+  ja: "ja",
+  jw: "jw",
+  kn: "kn",
+  kk: "kk",
+  km: "km",
+  ko: "ko",
+  lo: "lo",
+  la: "la",
+  lv: "lv",
+  ln: "ln",
+  lt: "lt",
+  lb: "lb",
+  mk: "mk",
+  mg: "mg",
+  ms: "ms",
+  ml: "ml",
+  mt: "mt",
+  mi: "mi",
+  mr: "mr",
+  mn: "mn",
+  ne: "ne",
+  no: "no",
+  nn: "nn",
+  oc: "oc",
+  pa: "pa",
+  ps: "ps",
+  fa: "fa",
+  pl: "pl",
+  ro: "ro",
+  ru: "ru",
+  sa: "sa",
+  sr: "sr",
+  sn: "sn",
+  sd: "sd",
+  si: "si",
+  sk: "sk",
+  sl: "sl",
+  so: "so",
+  su: "su",
+  sw: "sw",
+  sv: "sv",
+  tl: "tl",
+  tg: "tg",
+  ta: "ta",
+  tt: "tt",
+  te: "te",
+  th: "th",
+  bo: "bo",
+  tr: "tr",
+  tk: "tk",
+  uk: "uk",
+  ur: "ur",
+  uz: "uz",
+  vi: "vi",
+  cy: "cy",
+  yi: "yi",
+  yo: "yo"
+};
+
+// src/generated/assemblyai/schema/transcriptReadyStatus.ts
+var TranscriptReadyStatus = {
+  completed: "completed",
+  error: "error"
+};
+
+// src/generated/assemblyai/schema/transcriptStatus.ts
+var TranscriptStatus = {
+  queued: "queued",
+  processing: "processing",
+  completed: "completed",
+  error: "error"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssemblyAIAdapter,
+  AssemblyAITypes,
+  AssemblyAIWebhookHandler,
+  AzureSTTAdapter,
+  AzureWebhookHandler,
+  BaseAdapter,
+  BaseWebhookHandler,
+  DeepgramAdapter,
+  DeepgramWebhookHandler,
+  GladiaAdapter,
+  GladiaTypes,
+  GladiaWebhookHandler,
+  OpenAIWhisperAdapter,
+  SpeechmaticsAdapter,
+  SpeechmaticsWebhookHandler,
+  VoiceRouter,
+  WebhookRouter,
+  createAssemblyAIAdapter,
+  createAssemblyAIWebhookHandler,
+  createAzureSTTAdapter,
+  createAzureWebhookHandler,
+  createDeepgramAdapter,
+  createDeepgramWebhookHandler,
+  createGladiaAdapter,
+  createGladiaWebhookHandler,
+  createOpenAIWhisperAdapter,
+  createSpeechmaticsAdapter,
+  createVoiceRouter,
+  createWebhookRouter
+});
+//# sourceMappingURL=index.js.map