echogarden 2.10.2 → 3.0.0

package/src/api/TextLanguageDetection.ts

@@ -1,18 +1,17 @@
+import * as API from './API.js'
+
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
 import { Logger } from '../utilities/Logger.js'
 
-import * as API from './API.js'
-import { logToStderr } from '../utilities/Utilities.js'
 import { languageCodeToName } from '../utilities/Locale.js'
 import { LanguageDetectionResults } from './LanguageDetectionCommon.js'
 
-const log = logToStderr
-
-export async function detectTextLanguage(input: string, options: TextLanguageDetectionOptions): Promise<TextLanguageDetectionResult> {
-	const logger = new Logger()
-
+export async function detectTextLanguage(input: string, options: TextLanguageDetectionOptions, callbacks?: TextLanguageDetectionCallbacks): Promise<TextLanguageDetectionResult> {
 	options = extendDeep(defaultTextLanguageDetectionOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
+
+	const logger = new Logger(callbacks.logLevel)
 
 	const defaultLanguage = options.defaultLanguage!
 	const fallbackThresholdProbability = options.fallbackThresholdProbability!
@@ -84,22 +83,21 @@ export interface LanguageDetectionGroupResultsEntry {
 
 export type TextLanguageDetectionEngine = 'tinyld' | 'fasttext'
 
-export interface TextLanguageDetectionOptions {
+export interface TextLanguageDetectionOptions extends API.OperationOptions {
 	engine?: TextLanguageDetectionEngine
 	defaultLanguage?: string
 	fallbackThresholdProbability?: number
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Constants
-/////////////////////////////////////////////////////////////////////////////////////////////
-
 export const defaultTextLanguageDetectionOptions: TextLanguageDetectionOptions = {
 	engine: 'tinyld',
 	defaultLanguage: 'en',
 	fallbackThresholdProbability: 0.05,
 }
 
+export interface TextLanguageDetectionCallbacks extends API.OperationCallbacks {
+}
+
 export const textLanguageDetectionEngines: API.EngineMetadata[] = [
 	{
 		id: 'tinyld',

package/src/api/TextTranslation.ts

@@ -1,16 +1,19 @@
 import chalk from 'chalk'
+
+import * as API from './API.js'
+
 import { formatLanguageCodeWithName, normalizeIdentifierToLanguageCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { Logger } from '../utilities/Logger.js'
 import { extendDeep } from '../utilities/ObjectUtilities.js'
-import * as API from './API.js'
 import { defaultGoogleTranslateTextTranslationOptions, type GoogleTranslateTextTranslationOptions } from '../text-translation/GoogleTranslateTextTranslation.js'
 
-export async function translateText(inputText: string, options: TextTranslationOptions): Promise<TextTranslationResult> {
-	const logger = new Logger()
+export async function translateText(inputText: string, options: TextTranslationOptions, callbacks?: TextTranslationCallbacks): Promise<TextTranslationResult> {
+	options = extendDeep(defaultTextTranslationOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
 
-	const startTimestamp = logger.getTimestamp()
+	const logger = new Logger(callbacks.logLevel)
 
-	options = extendDeep(defaultTextTranslationOptions, options)
+	const startTimestamp = logger.getTimestamp()
 
 	if (options.sourceLanguage) {
 		const languageData = await parseLangIdentifier(options.sourceLanguage)
@@ -21,7 +24,11 @@ export async function translateText(inputText: string, options: TextTranslationO
 		logger.logTitledMessage('Source language specified', formatLanguageCodeWithName(options.sourceLanguage))
 	} else {
 		logger.start('No source language specified. Detect text language')
-		const { detectedLanguage } = await API.detectTextLanguage(inputText, options.languageDetection || {})
+		const { detectedLanguage } = await API.detectTextLanguage(
+			inputText,
+			options.languageDetection!,
+			{ abortSignal: callbacks.abortSignal, logLevel: 'warning' },
+		)
 
 		options.sourceLanguage = detectedLanguage
 
@@ -44,9 +51,14 @@ export async function translateText(inputText: string, options: TextTranslationO
 
 			logger.end()
 
-			logger.logTitledMessage(`Warning`, `The nllb text translation engine is currently a work-in-progress and doesn't work correctly.`, chalk.yellow, 'warning')
+			logger.logTitledMessage(`Warning`, `The nllb text translation engine is currently a work-in-progress and doesn't work correctly.`, 'warning')
 
-			translationPairs = await NLLBTextTranslation.translateText(inputText, options.sourceLanguage, options.targetLanguage)
+			translationPairs = await NLLBTextTranslation.translateText(
+				inputText,
+				options.sourceLanguage,
+				options.targetLanguage,
+				callbacks,
+			)
 
 			translatedText = translationPairs.map(pair => {
 				const translated = pair.translatedText
@@ -68,7 +80,14 @@ export async function translateText(inputText: string, options: TextTranslationO
 
 			logger.end();
 
-			({ translationPairs, translatedText } = await GoogleTranslateTextTranslation.translateText(inputText, options.sourceLanguage, options.targetLanguage, options.plainText!, googleTranslateOptions))
+			({ translationPairs, translatedText } = await GoogleTranslateTextTranslation.translateText(
+				inputText,
+				options.sourceLanguage,
+				options.targetLanguage,
+				options.plainText!,
+				googleTranslateOptions,
+				callbacks,
+			))
 
 			break
 		}
@@ -78,9 +97,15 @@ export async function translateText(inputText: string, options: TextTranslationO
 
 			logger.end()
 
-			logger.logTitledMessage(`Warning`, `The deepl text translation engine is currently a work-in-progress and doesn't work correctly.`, chalk.yellow, 'warning')
+			logger.logTitledMessage(`Warning`, `The deepl text translation engine is currently a work-in-progress and doesn't work correctly.`, 'warning')
+
+			translationPairs = await DeepLTextTranslation.translateText(
+				inputText,
+				options.sourceLanguage,
+				options.targetLanguage,
+				callbacks
+			)
 
-			translationPairs = await DeepLTextTranslation.translateText(inputText, options.sourceLanguage, options.targetLanguage)
 			translatedText = ''
 
 			break
@@ -95,7 +120,7 @@ export async function translateText(inputText: string, options: TextTranslationO
 	logger.end()
 
 	logger.log('')
-	logger.logDuration(`Total text translation time`, startTimestamp, chalk.magentaBright)
+	logger.logDuration(`Total text translation time`, startTimestamp, 'info', chalk.magentaBright)
 
 	return {
 		text: inputText,
@@ -108,7 +133,7 @@ export async function translateText(inputText: string, options: TextTranslationO
 	}
 }
 
-export interface TextTranslationOptions {
+export interface TextTranslationOptions extends API.OperationOptions {
 	engine?: TextTranslationEngine
 
 	sourceLanguage?: string
@@ -150,7 +175,8 @@ export const defaultTextTranslationOptions: TextTranslationOptions = {
 	sourceLanguage: undefined,
 	targetLanguage: 'en',
 
-	languageDetection: undefined,
+	languageDetection: {
+	},
 
 	plainText: {
 		paragraphBreaks: 'double',
@@ -166,23 +192,14 @@ export const defaultTextTranslationOptions: TextTranslationOptions = {
 	},
 }
 
+export interface TextTranslationCallbacks extends API.OperationCallbacks {
+}
+
 export const textTranslationEngines: API.EngineMetadata[] = [
-	{
-		id: 'nllb',
-		name: 'NLLB',
-		description: 'No Language Left Behind (NLLB) is a deep learning machine translation model by Facebook Research (work-in-progress, do not use).',
-		type: 'local'
-	},
 	{
 		id: 'google-translate',
 		name: 'Google Translate',
 		description: 'Unoffical text translation API used by the Google Translate web interface.',
 		type: 'cloud'
 	},
-	{
-		id: 'deepl',
-		name: 'DeepL',
-		description: 'Unoffical text translation API used by the DeepL web interface (work-in-progress, do not use).',
-		type: 'cloud'
-	},
 ]

package/src/api/TimelineTranslationAlignment.ts

@@ -1,23 +1,26 @@
 import chalk from 'chalk'
+
+import * as API from './API.js'
+
 import { AudioSourceParam, RawAudio, ensureRawAudio } from '../audio/AudioUtilities.js'
 import { SubtitlesConfig } from '../subtitles/Subtitles.js'
 import { formatLanguageCodeWithName, getShortLanguageCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { Logger } from '../utilities/Logger.js'
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 import { Timeline, addWordTextOffsetsToTimelineInPlace, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
-import * as API from './API.js'
 
-export async function alignTimelineTranslation(inputTimeline: Timeline, translatedTranscript: string, options: TimelineTranslationAlignmentOptions): Promise<TimelineTranslationAlignmentResult> {
-	const logger = new Logger()
+export async function alignTimelineTranslation(inputTimeline: Timeline, translatedTranscript: string, options: TimelineTranslationAlignmentOptions, callbacks?: TimelineTranslationAlignmentCallbacks): Promise<TimelineTranslationAlignmentResult> {
+	options = extendDeep(defaultTimelineTranslationAlignmentOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
 
-	const startTimestamp = logger.getTimestamp()
+	const logger = new Logger(callbacks.logLevel)
 
-	options = extendDeep(defaultTimelineTranslationAlignmentOptions, options)
+	const startTimestamp = logger.getTimestamp()
 
 	let rawAudio: RawAudio | undefined
 
 	if (options.audio) {
-		rawAudio = await ensureRawAudio(options.audio)
+		rawAudio = await ensureRawAudio(options.audio, undefined, undefined, callbacks)
 	}
 
 	let sourceLanguage = options.sourceLanguage
@@ -33,7 +36,11 @@ export async function alignTimelineTranslation(inputTimeline: Timeline, translat
 		logger.start('No source language specified. Detect source language')
 
 		const timelineText = inputTimeline.map(entry => entry.text).join(' ')
-		const { detectedLanguage } = await API.detectTextLanguage(timelineText, options.languageDetection || {})
+		const { detectedLanguage } = await API.detectTextLanguage(
+			timelineText,
+			options.languageDetection!,
+			{ abortSignal: callbacks.abortSignal, logLevel: 'warning' },
+		)
 
 		sourceLanguage = detectedLanguage
 
@@ -52,7 +59,12 @@ export async function alignTimelineTranslation(inputTimeline: Timeline, translat
 		logger.logTitledMessage('Target language specified', formatLanguageCodeWithName(targetLanguage))
 	} else {
 		logger.start('No target language specified. Detect target language')
-		const { detectedLanguage } = await API.detectTextLanguage(translatedTranscript, options.languageDetection || {})
+
+		const { detectedLanguage } = await API.detectTextLanguage(
+			translatedTranscript,
+			options.languageDetection!,
+			{ abortSignal: callbacks.abortSignal, logLevel: 'warning' },
+		)
 
 		targetLanguage = detectedLanguage
 
@@ -83,7 +95,9 @@ export async function alignTimelineTranslation(inputTimeline: Timeline, translat
 			mappedWordTimeline = await alignTimelineToTextSemantically(
 				inputTimeline,
 				translatedTranscript,
-				targetLanguage)
+				targetLanguage,
+				callbacks,
+			)
 
 			break
 		}
@@ -100,7 +114,7 @@ export async function alignTimelineTranslation(inputTimeline: Timeline, translat
 	const { segmentTimeline: mappedTimeline } = await wordTimelineToSegmentSentenceTimeline(mappedWordTimeline, translatedTranscript, targetLanguage)
 
 	logger.end()
-	logger.logDuration(`Total timeline translation alignment time`, startTimestamp, chalk.magentaBright)
+	logger.logDuration(`Total timeline translation alignment time`, startTimestamp, 'info', chalk.magentaBright)
 
 	logger.end()
 
@@ -126,7 +140,7 @@ export interface TimelineTranslationAlignmentResult {
 	rawAudio?: RawAudio
 }
 
-export interface TimelineTranslationAlignmentOptions {
+export interface TimelineTranslationAlignmentOptions extends API.OperationOptions {
 	engine?: 'e5'
 
 	sourceLanguage?: string
@@ -152,11 +166,25 @@ const defaultTimelineTranslationAlignmentOptions: TimelineTranslationAlignmentOp
 
 	audio: undefined,
 
-	languageDetection: undefined,
+	languageDetection: {
+	},
 
-	subtitles: undefined,
+	subtitles: {
+	},
 
 	e5: {
 		model: 'small-fp16',
 	}
 }
+
+export interface TimelineTranslationAlignmentCallbacks extends API.OperationCallbacks {
+}
+
+export const timelineTranslationAlignmentEngines: API.EngineMetadata[] = [
+	{
+		id: 'e5',
+		name: 'E5',
+		description: 'E5 embedding model.',
+		type: 'local'
+	},
+]

package/src/api/TranscriptAndTranslationAlignment.ts

@@ -1,23 +1,23 @@
+import chalk from 'chalk'
+
+import * as API from './API.js'
+
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
-import { logToStderr } from '../utilities/Utilities.js'
 import { AudioSourceParam, RawAudio } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
-import * as API from './API.js'
 import { Timeline } from '../utilities/Timeline.js'
-import chalk from 'chalk'
 import { type SubtitlesConfig } from '../subtitles/Subtitles.js'
 
-const log = logToStderr
+export async function alignTranscriptAndTranslation(input: AudioSourceParam, transcript: string, translatedTranscript: string, options: TranscriptAndTranslationAlignmentOptions, callbacks?: TranscriptAndTranslationAlignmentCallbacks): Promise<TranscriptAndTranslationAlignmentResult> {
+	options = extendDeep(defaultTranscriptAndTranslationAlignmentOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
 
-export async function alignTranscriptAndTranslation(input: AudioSourceParam, transcript: string, translatedTranscript: string, options: TranscriptAndTranslationAlignmentOptions): Promise<TranscriptAndTranslationAlignmentResult> {
-	const logger = new Logger()
+	const logger = new Logger(callbacks.logLevel)
 
 	const startTimestamp = logger.getTimestamp()
 
-	options = extendDeep(defaultTranscriptAndTranslationAlignmentOptions, options)
-
 	if (options.sourceLanguage && !options.alignment?.language) {
 		options.alignment = extendDeep(options.alignment || {}, { language: options.sourceLanguage })
 	}
@@ -31,16 +31,26 @@ export async function alignTranscriptAndTranslation(input: AudioSourceParam, tra
 
 	switch (options.engine) {
 		case 'two-stage': {
-			logger.logTitledMessage(`Start stage 1`, `Align speech to transcript`, chalk.magentaBright)
+			logger.logTitledMessage(`Start stage 1`, `Align speech to transcript`, 'info', chalk.magentaBright)
 			logger.end()
 
-			alignmentResult = await API.align(input, transcript, options.alignment || {})
+			alignmentResult = await API.align(
+				input,
+				transcript,
+				options.alignment!,
+				callbacks
+			)
 
 			logger.log(``)
-			logger.logTitledMessage(`Start stage 2`, `Align timeline to translated transcript`, chalk.magentaBright)
+			logger.logTitledMessage(`Start stage 2`, `Align timeline to translated transcript`, 'info', chalk.magentaBright)
 			logger.end()
 
-			timelineAlignmentResult = await API.alignTimelineTranslation(alignmentResult.timeline, translatedTranscript, options.timelineAlignment || {})
+			timelineAlignmentResult = await API.alignTimelineTranslation(
+				alignmentResult.timeline,
+				translatedTranscript,
+				options.timelineAlignment!,
+				callbacks,
+			)
 
 			break
 		}
@@ -53,7 +63,7 @@ export async function alignTranscriptAndTranslation(input: AudioSourceParam, tra
 	logger.end()
 
 	logger.log(``)
-	logger.logDuration(`Total transcript and translation alignment time`, startTimestamp, chalk.magentaBright)
+	logger.logDuration(`Total transcript and translation alignment time`, startTimestamp, 'info', chalk.magentaBright)
 
 	return {
 		timeline: alignmentResult.timeline,
@@ -94,7 +104,7 @@ export interface TranscriptAndTranslationAlignmentResult {
 
 export type TranscriptAndTranslationAlignmentEngine = 'two-stage'
 
-export interface TranscriptAndTranslationAlignmentOptions {
+export interface TranscriptAndTranslationAlignmentOptions extends API.OperationOptions {
 	engine?: TranscriptAndTranslationAlignmentEngine
 
 	sourceLanguage?: string
@@ -110,7 +120,7 @@ export interface TranscriptAndTranslationAlignmentOptions {
 
 	languageDetection?: API.TextLanguageDetectionOptions
 
-	vad?: API.VADOptions
+	vad?: API.VoiceActivityDetectionOptions
 
 	plainText?: API.PlainTextOptions
 
@@ -154,6 +164,9 @@ export const defaultTranscriptAndTranslationAlignmentOptions: TranscriptAndTrans
 	},
 }
 
+export interface TranscriptAndTranslationAlignmentCallbacks extends API.OperationCallbacks {
+}
+
 export const TranscriptAndTranslationAlignmentEngines: API.EngineMetadata[] = [
 	{
 		id: 'two-stage',

package/src/api/TranslationAlignment.ts

@@ -1,52 +1,56 @@
+import chalk from 'chalk'
+
+import * as API from './API.js'
+
 import { extendDeep } from '../utilities/ObjectUtilities.js'
 
-import { logToStderr } from '../utilities/Utilities.js'
 import { AudioSourceParam, RawAudio, ensureRawAudio, normalizeAudioLevelInPlace, trimAudioEnd } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 
-import * as API from './API.js'
 import { Timeline, addWordTextOffsetsToTimelineInPlace, wordTimelineToSegmentSentenceTimeline } from '../utilities/Timeline.js'
 import { formatLanguageCodeWithName, getShortLanguageCode, normalizeIdentifierToLanguageCode, parseLangIdentifier } from '../utilities/Locale.js'
 import { type WhisperAlignmentOptions } from '../recognition/WhisperSTT.js'
-import chalk from 'chalk'
 import { type SubtitlesConfig } from '../subtitles/Subtitles.js'
 
-const log = logToStderr
+export async function alignTranslation(input: AudioSourceParam, translatedTranscript: string, options: TranslationAlignmentOptions, callbacks?: TranslationAlignmentCallbacks): Promise<TranslationAlignmentResult> {
+	options = extendDeep(defaultTranslationAlignmentOptions, options)
+	callbacks = { logLevel: API.getGlobalLogLevel(), ...callbacks }
 
-export async function alignTranslation(input: AudioSourceParam, translatedTranscript: string, options: TranslationAlignmentOptions): Promise<TranslationAlignmentResult> {
-	const logger = new Logger()
+	const logger = new Logger(callbacks.logLevel)
 
 	const startTimestamp = logger.getTimestamp()
 
-	options = extendDeep(defaultTranslationAlignmentOptions, options)
-
-	const inputRawAudio = await ensureRawAudio(input)
+	const inputRawAudio = await ensureRawAudio(input, undefined, undefined, callbacks)
 
 	let sourceRawAudio: RawAudio
 	let isolatedRawAudio: RawAudio | undefined
 	let backgroundRawAudio: RawAudio | undefined
 
 	if (options.isolate) {
-		logger.log(``)
-		logger.end();
+		logger.logTitledMessage(`Isolate vocals`, '');
 
-		({ isolatedRawAudio, backgroundRawAudio } = await API.isolate(inputRawAudio, options.sourceSeparation!))
+		({ isolatedRawAudio, backgroundRawAudio } = await API.isolate(
+			inputRawAudio,
+			options.sourceSeparation!,
+			{ ...callbacks, logLevel: logger.logLevel }))
 
 		logger.end()
-		logger.log(``)
 
 		logger.start(`Resample audio to 16kHz mono`)
-		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1)
+		sourceRawAudio = await ensureRawAudio(isolatedRawAudio, 16000, 1, callbacks)
 	} else {
 		logger.start(`Resample audio to 16kHz mono`)
-		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1)
+		sourceRawAudio = await ensureRawAudio(inputRawAudio, 16000, 1, callbacks)
 	}
 
 	let sourceUncropTimeline: Timeline | undefined
 
 	if (options.crop) {
 		logger.start('Crop using voice activity detection');
-		({ timeline: sourceUncropTimeline, croppedRawAudio: sourceRawAudio } = await API.detectVoiceActivity(sourceRawAudio, options.vad!))
+		({ timeline: sourceUncropTimeline, croppedRawAudio: sourceRawAudio } = await API.detectVoiceActivity(
+			sourceRawAudio,
+			options.vad!,
+			{ ...callbacks, logLevel: 'warning' }))
 
 		logger.end()
 	}
@@ -69,7 +73,10 @@ export async function alignTranslation(input: AudioSourceParam, translatedTransc
 		logger.logTitledMessage('Source language specified', formatLanguageCodeWithName(sourceLanguage))
 	} else {
 		logger.start('No source language specified. Detect speech language')
-		const { detectedLanguage } = await API.detectSpeechLanguage(sourceRawAudio, options.languageDetection || {})
+		const { detectedLanguage } = await API.detectSpeechLanguage(
+			sourceRawAudio,
+			options.languageDetection!,
+			{ ...callbacks, logLevel: 'warning' })
 
 		sourceLanguage = detectedLanguage
 
@@ -86,6 +93,7 @@ export async function alignTranslation(input: AudioSourceParam, translatedTransc
 	switch (options.engine) {
 		case 'whisper': {
 			const WhisperSTT = await import('../recognition/WhisperSTT.js')
+			const WhisperCommon = await import('../recognition/WhisperCommon.js')
 
 			const shortSourceLanguageCode = getShortLanguageCode(sourceLanguage)
 			const shortTargetLanguageCode = getShortLanguageCode(targetLanguage)
@@ -98,17 +106,35 @@ export async function alignTranslation(input: AudioSourceParam, translatedTransc
 				throw new Error('Both translation source and target languages are English')
 			}
 
-			const whisperAlignmnentOptions = options.whisper!
+			const whisperAlignmnentOptions: WhisperAlignmentOptions = extendDeep(WhisperSTT.defaultWhisperAlignmentOptions, options.whisper!)
 
-			const { modelName, modelDir } = await WhisperSTT.loadPackagesAndGetPaths(whisperAlignmnentOptions.model, shortSourceLanguageCode)
+			const { modelId, modelPath } = await WhisperCommon.loadModelPackage(
+				whisperAlignmnentOptions.model,
+				shortSourceLanguageCode,
+				callbacks,
+			)
+
+			const { libPath } = await WhisperSTT.loadLibraryPackages(
+				whisperAlignmnentOptions.enableGPU,
+				callbacks,
+			)
 
 			logger.end()
 
-			if (modelName.endsWith('.en')) {
+			if (modelId.endsWith('.en')) {
 				throw new Error('Whisper translation tasks are only possible with a multilingual model')
 			}
 
-			mappedTimeline = await WhisperSTT.alignEnglishTranslation(sourceRawAudio, translatedTranscript, modelName, modelDir, shortSourceLanguageCode, whisperAlignmnentOptions)
+			mappedTimeline = await WhisperSTT.alignEnglishTranslation(
+				sourceRawAudio,
+				translatedTranscript,
+				modelId,
+				modelPath,
+				libPath,
+				shortSourceLanguageCode,
+				whisperAlignmnentOptions,
+				callbacks
+			)
 
 			break
 		}
@@ -130,7 +156,7 @@ export async function alignTranslation(input: AudioSourceParam, translatedTransc
 	const { segmentTimeline } = await wordTimelineToSegmentSentenceTimeline(mappedTimeline, translatedTranscript, sourceLanguage, options.plainText?.paragraphBreaks, options.plainText?.whitespace)
 
 	logger.end()
-	logger.logDuration(`Total translation alignment time`, startTimestamp, chalk.magentaBright)
+	logger.logDuration(`Total translation alignment time`, startTimestamp, 'info', chalk.magentaBright)
 
 	return {
 		timeline: segmentTimeline,
@@ -161,7 +187,7 @@ export interface TranslationAlignmentResult {
 
 export type TranslationAlignmentEngine = 'whisper'
 
-export interface TranslationAlignmentOptions {
+export interface TranslationAlignmentOptions extends API.OperationOptions {
 	engine?: TranslationAlignmentEngine
 
 	sourceLanguage?: string
@@ -173,7 +199,7 @@ export interface TranslationAlignmentOptions {
 
 	languageDetection?: API.SpeechLanguageDetectionOptions
 
-	vad?: API.VADOptions
+	vad?: API.VoiceActivityDetectionOptions
 
 	plainText?: API.PlainTextOptions
 
@@ -216,6 +242,9 @@ export const defaultTranslationAlignmentOptions: TranslationAlignmentOptions = {
 	}
 }
 
+export interface TranslationAlignmentCallbacks extends API.OperationCallbacks {
+}
+
 export const translationAlignmentEngines: API.EngineMetadata[] = [
 	{
 		id: 'whisper',