@soniox/node 2.0.2 → 2.1.0

package/dist/index.cjs

@@ -1875,11 +1875,14 @@ var SonioxAuthAPI = class {
 	* const ttsKey = await client.auth.createTemporaryKey({
 	*   usage_type: 'tts_rt',
 	*   expires_in_seconds: 300,
+	*   single_use: true,
+	*   max_session_duration_seconds: 600,
 	* });
 	* ```
 	*/
 	async createTemporaryKey(request, signal) {
 		if (!Number.isFinite(request.expires_in_seconds) || request.expires_in_seconds < 1 || request.expires_in_seconds > 3600) throw new Error("expires_in_seconds must be a finite number between 1 and 3600");
+		if (request.max_session_duration_seconds !== void 0 && (!Number.isFinite(request.max_session_duration_seconds) || request.max_session_duration_seconds < 1 || request.max_session_duration_seconds > 18e3)) throw new Error("max_session_duration_seconds must be a finite number between 1 and 18000");
 		return (await this.http.request({
 			method: "POST",
 			path: "/v1/auth/temporary-api-key",
@@ -1889,6 +1892,38 @@ var SonioxAuthAPI = class {
 	}
 };
 
+//#endregion
+//#region src/async/concurrency-limits.ts
+var SonioxConcurrencyLimitsAPI = class {
+	constructor(http) {
+		this.http = http;
+	}
+	/**
+	* Retrieves current concurrency counts and configured limits.
+	*
+	* Values are region-scoped according to the client's configured REST API
+	* endpoint.
+	*
+	* @param signal - Optional AbortSignal for cancellation.
+	* @returns Current counts and configured limits for project and organization scopes.
+	* @throws {@link SonioxHttpError} On API errors.
+	*
+	* @example
+	* ```typescript
+	* const limits = await client.concurrencyLimits.get();
+	* console.log(limits.project.current.transcribe_concurrent);
+	* console.log(limits.project.limits.transcribe_concurrent);
+	* ```
+	*/
+	async get(signal) {
+		return (await this.http.request({
+			method: "GET",
+			path: "/v1/concurrency-limits",
+			...signal && { signal }
+		})).data;
+	}
+};
+
 //#endregion
 //#region src/async/files.ts
 /**
@@ -2230,6 +2265,27 @@ var SonioxFilesAPI = class {
 		})).data, this.http, limit, signal);
 	}
 	/**
+	* Returns the total number of files, split by source.
+	*
+	* @param options - Optional cancellation parameters.
+	* @returns Total file counts for Playground, Public API, and all sources.
+	* @throws {@link SonioxHttpError} On API errors.
+	*
+	* @example
+	* ```typescript
+	* const counts = await client.files.count();
+	* console.log(counts.total);
+	* ```
+	*/
+	async count(options = {}) {
+		const { signal } = options;
+		return (await this.http.request({
+			method: "GET",
+			path: "/v1/files/count",
+			...signal && { signal }
+		})).data;
+	}
+	/**
 	* Retrieve metadata for an uploaded file.
 	*
 	* @param file - The UUID of the file or a SonioxFile instance
@@ -2344,6 +2400,186 @@ var SonioxModelsAPI = class {
 	}
 };
 
+//#endregion
+//#region src/async/translation.ts
+/**
+* Reshape a transcript produced by a translation-enabled transcription into a
+* structured {@link SonioxTranslation} result.
+*
+* This is the same logic `SonioxTranslationJob.getTranslation()` applies.
+* Use it directly in webhook handlers or anywhere else you already have a
+* transcript in hand.
+*
+* @param transcript - Transcript (or any object with a `tokens` array) emitted
+*   for a translation-enabled transcription.
+* @param mode - Whether to reshape as one-way or two-way; the discriminator
+*   tells the helper which result shape to produce.
+* @returns A {@link SonioxTranslation} keyed on `mode`.
+*
+* @example
+* ```typescript
+* import { translateFromTranscript } from '@soniox/node';
+*
+* // From a webhook handler that just received the transcript
+* const result = translateFromTranscript(transcript, { type: 'one_way', to: 'es' });
+* console.log(result.translation_text);
+* ```
+*/
+function translateFromTranscript(transcript, mode) {
+	const segments = reshapeTokens(transcript.tokens);
+	const duration_ms = computeDurationMs(transcript.tokens);
+	if (mode.type === "two_way") return {
+		mode: "two_way",
+		language_a: mode.language_a,
+		language_b: mode.language_b,
+		duration_ms,
+		segments
+	};
+	let original_text = "";
+	let translation_text = "";
+	for (const segment of segments) {
+		for (const token of segment.original_tokens) original_text += token.text;
+		for (const token of segment.translation_tokens ?? []) translation_text += token.text;
+	}
+	return {
+		mode: "one_way",
+		...mode.from !== void 0 && { from: mode.from },
+		to: mode.to,
+		duration_ms,
+		segments,
+		original_text,
+		translation_text
+	};
+}
+/**
+* Reshape a flat token stream into per-utterance translation segments.
+*
+* Internal step; exported only via {@link translateFromTranscript}.
+*/
+function reshapeTokens(tokens) {
+	if (tokens.length === 0) return [];
+	return mergeChunks(splitIntoChunks(tokens));
+}
+/**
+* Walk tokens in order and start a new chunk whenever the speaker, language
+* (target lang for translations, source lang otherwise), or "is this a
+* translation token" flag changes.
+*/
+function splitIntoChunks(tokens) {
+	const chunks = [];
+	let current = null;
+	for (const token of tokens) {
+		const speaker = token.speaker ?? void 0;
+		const language = token.language ?? void 0;
+		const isTranslation = token.translation_status === "translation";
+		if (current === null || current.speaker !== speaker || current.language !== language || current.isTranslation !== isTranslation) {
+			current = {
+				speaker,
+				language,
+				isTranslation,
+				tokens: []
+			};
+			chunks.push(current);
+		}
+		current.tokens.push(token);
+	}
+	return chunks;
+}
+/**
+* Pair each `'original'` chunk with the immediately following translation
+* chunk for the same speaker, and emit a {@link TranslationSegment} for
+* every logical utterance.
+*
+* Soniox emits tokens in strict order: original chunk → translation chunk →
+* next original chunk → next translation chunk. So a chunk of
+* `translation_status: 'original'` tokens is always followed by its
+* translation when the same-speaker next chunk is a translation chunk.
+*
+* Chunks of `translation_status: 'none'` (third-language pass-through under
+* `between`) are never followed by a translation and stay standalone.
+*/
+function mergeChunks(chunks) {
+	const segments = [];
+	let i = 0;
+	while (i < chunks.length) {
+		const chunk = chunks[i];
+		if (!chunk) {
+			i += 1;
+			continue;
+		}
+		if (chunk.isTranslation) {
+			segments.push(buildSegmentFromChunks(void 0, chunk));
+			i += 1;
+			continue;
+		}
+		const firstStatus = chunk.tokens[0]?.translation_status;
+		const next = chunks[i + 1];
+		if (firstStatus === "original" && next && next.isTranslation && next.speaker === chunk.speaker) {
+			segments.push(buildSegmentFromChunks(chunk, next));
+			i += 2;
+			continue;
+		}
+		segments.push(buildSegmentFromChunks(chunk, void 0));
+		i += 1;
+	}
+	return segments;
+}
+/**
+* Build a {@link TranslationSegment} from at most one original chunk and at
+* most one translation chunk. At least one must be provided.
+*/
+function buildSegmentFromChunks(original, translation) {
+	const original_tokens = original?.tokens ?? [];
+	const translation_tokens = translation?.tokens ?? [];
+	const speaker = original?.speaker ?? translation?.speaker;
+	const from = resolveFrom(original_tokens, translation_tokens);
+	const to = translation_tokens[0]?.language ?? void 0;
+	const firstOriginal = original_tokens[0];
+	const lastOriginal = original_tokens[original_tokens.length - 1];
+	const original_text = original_tokens.reduce((acc, t) => acc + t.text, "");
+	const translation_text = translation_tokens.reduce((acc, t) => acc + t.text, "");
+	const segment = {
+		from,
+		original_text,
+		original_tokens
+	};
+	if (firstOriginal?.start_ms !== void 0) segment.start_ms = firstOriginal.start_ms;
+	if (lastOriginal?.end_ms !== void 0) segment.end_ms = lastOriginal.end_ms;
+	if (speaker !== void 0) segment.speaker = speaker;
+	if (translation_tokens.length > 0) {
+		if (to !== void 0) segment.to = to;
+		segment.translation_text = translation_text;
+		segment.translation_tokens = translation_tokens;
+	}
+	return segment;
+}
+/**
+* Resolve a segment's `from` (source language) field.
+*
+* Original tokens carry the source language in `language`; translation
+* tokens carry it in `source_language`. When neither is available we fall
+* back to an empty string so the field stays a `string`.
+*/
+function resolveFrom(originals, translations) {
+	const fromOriginal = originals[0]?.language;
+	if (fromOriginal !== void 0 && fromOriginal !== null) return fromOriginal;
+	const fromTranslation = translations[0]?.source_language;
+	if (fromTranslation !== void 0 && fromTranslation !== null) return fromTranslation;
+	return "";
+}
+/**
+* Total audio duration in ms. Translation tokens carry no timestamps, so we
+* scan only original tokens (i.e. not `translation_status: 'translation'`).
+*/
+function computeDurationMs(tokens) {
+	let max = 0;
+	for (const token of tokens) {
+		if (token.translation_status === "translation") continue;
+		if (token.end_ms !== void 0 && token.end_ms > max) max = token.end_ms;
+	}
+	return max;
+}
+
 //#endregion
 //#region src/async/stt.ts
 /**
@@ -2464,16 +2700,25 @@ function segmentTranscript(tokens, options = {}) {
 	return segmentTokens(tokens, options, buildSegment);
 }
 /**
-* Helper to build a segment from a list of tokens
+* Helper to build a segment from a list of tokens.
+*
+* `start_ms` / `end_ms` are populated from the first/last tokens that carry
+* timestamps. Translation tokens have no timing, so a translation-only
+* segment ends up without timestamps.
 */
 function buildSegment(tokens, speaker, language) {
-	const firstToken = tokens[0];
-	const lastToken = tokens[tokens.length - 1];
-	if (!firstToken || !lastToken) throw new Error("Cannot build segment from an empty token array");
+	if (tokens.length === 0) throw new Error("Cannot build segment from an empty token array");
+	const text = tokens.map((t) => t.text).join("");
+	let start_ms;
+	let end_ms;
+	for (const token of tokens) {
+		if (start_ms === void 0 && token.start_ms !== void 0) start_ms = token.start_ms;
+		if (token.end_ms !== void 0) end_ms = token.end_ms;
+	}
 	return {
-		text: tokens.map((t) => t.text).join(""),
-		start_ms: firstToken.start_ms,
-		end_ms: lastToken.end_ms,
+		text,
+		...start_ms !== void 0 && { start_ms },
+		...end_ms !== void 0 && { end_ms },
 		...speaker != null && { speaker },
 		...language != null && { language },
 		tokens
@@ -2827,6 +3072,66 @@ var SonioxTranscription = class SonioxTranscription {
 	}
 };
 /**
+* A translation job.
+*
+* Mirrors {@link SonioxTranscription}, with an additional translation mode and
+* helpers that reshape the completed transcript into a {@link SonioxTranslation}.
+*/
+var SonioxTranslationJob = class SonioxTranslationJob extends SonioxTranscription {
+	/**
+	* Pre-fetched translation result. Only available when using `translate()`
+	* with `wait: true`, `fetch_translation !== false`, and the job completed
+	* successfully.
+	*/
+	translation;
+	constructor(data, http, _mode, transcript, translation) {
+		super(data, http, transcript);
+		this._mode = _mode;
+		this.translation = translation;
+	}
+	/**
+	* Retrieves and reshapes the completed transcript into a structured
+	* translation result.
+	*
+	* Returns cached translation if available. Use `force: true` to bypass the
+	* cached translation and fetch a fresh transcript from the API.
+	*/
+	async getTranslation(options) {
+		const { force, signal } = options ?? {};
+		if (!force && this.translation !== void 0) return this.translation;
+		const transcript = await this.getTranscript({
+			...force !== void 0 && { force },
+			...signal !== void 0 && { signal }
+		});
+		if (!transcript) return null;
+		return translateFromTranscript(transcript, this._mode);
+	}
+	/**
+	* Alias for {@link SonioxTranslationJob.getTranslation}.
+	*/
+	async fetchTranslation(options) {
+		return this.getTranslation(options);
+	}
+	/**
+	* Re-fetches this translation job to get the latest status.
+	*/
+	async refresh(signal) {
+		return new SonioxTranslationJob((await this._http.request({
+			method: "GET",
+			path: `/v1/transcriptions/${this.id}`,
+			...signal && { signal }
+		})).data, this._http, this._mode);
+	}
+	/**
+	* Waits for the translation job to complete or fail.
+	*/
+	async wait(options = {}) {
+		const completed = await super.wait(options);
+		if (completed instanceof SonioxTranslationJob) return completed;
+		return new SonioxTranslationJob(completed.toJSON(), this._http, this._mode);
+	}
+};
+/**
 * Result set for transcription listing.
 */
 var TranscriptionListResult = class {
@@ -2967,6 +3272,26 @@ var SonioxSttApi = class {
 		})).data, this.http, options, signal);
 	}
 	/**
+	* Returns the total number of transcriptions, split by request scope.
+	*
+	* @param signal - Optional AbortSignal for request cancellation.
+	* @returns Total transcription counts for Playground, Public API, and all scopes.
+	* @throws {@link SonioxHttpError} On API errors.
+	*
+	* @example
+	* ```typescript
+	* const counts = await client.stt.count();
+	* console.log(counts.total);
+	* ```
+	*/
+	async count(signal) {
+		return (await this.http.request({
+			method: "GET",
+			path: "/v1/transcriptions/count",
+			...signal && { signal }
+		})).data;
+	}
+	/**
 	* Retrieves a transcription by ID
 	*
 	* @param id - The UUID of the transcription or a SonioxTranscription instance.
@@ -3304,6 +3629,78 @@ var SonioxSttApi = class {
 		}
 	}
 	/**
+	* Starts a translation job.
+	*
+	* Sugar around {@link SonioxSttApi.transcribe}: configures translation from
+	* the supplied {@link TranslateMode} (`{ to }`, `{ to, from }`, or
+	* `{ between }`) and returns a {@link SonioxTranslationJob}. With
+	* `wait: true`, waits for completion before returning, mirroring
+	* {@link SonioxSttApi.transcribe}.
+	*
+	* Method-owned fields (cannot be set by the caller):
+	* - `translation` — derived from `to` / `between`.
+	* - `language_hints` + `language_hints_strict: true` — derived from
+	*   `from` / `between`.
+	* - `enable_language_identification: true` — always. The reshape step
+	*   relies on every token carrying a `language` field to group originals
+	*   with their translations.
+	* - `fetch_transcript` — derived from `fetch_translation` when `wait=true`.
+	*
+	* @param options - Mode, audio source, and pass-through options.
+	* @returns The translation job.
+	* @throws {@link SonioxHttpError} On API errors.
+	* @throws `Error` On validation errors or wait timeout.
+	*
+	* @example
+	* ```typescript
+	* // One-way: detect any source language, translate to Spanish.
+	* const job = await client.stt.translate({
+	*     audio_url: 'https://soniox.com/media/examples/coffee_shop.mp3',
+	*     to: 'es',
+	* });
+	*
+	* const completed = await job.wait();
+	* const result = await completed.getTranslation();
+	* console.log(result?.translation_text);
+	*
+	* // One-way with explicit source language.
+	* const explicitJob = await client.stt.translate({
+	*     file: buffer,
+	*     filename: 'meeting.mp3',
+	*     from: 'en',
+	*     to: 'es',
+	*     wait: true,
+	* });
+	* console.log(explicitJob.translation?.translation_text);
+	*
+	* // Two-way: bidirectional translation between two languages.
+	* const twoWayJob = await client.stt.translate({
+	*     audio_url: 'https://soniox.com/media/examples/coffee_shop.mp3',
+	*     between: ['en', 'es'],
+	*     enable_speaker_diarization: true,
+	*     wait: true,
+	* });
+	* for (const seg of twoWayJob.translation?.segments ?? []) {
+	*     console.log(`[${seg.from}] ${seg.original_text}`);
+	*     if (seg.translation_text) {
+	*         console.log(`  → [${seg.to}] ${seg.translation_text}`);
+	*     }
+	* }
+	* ```
+	*/
+	async translate(options) {
+		const { translation, language_hints, mode } = resolveTranslateMode(options);
+		const transcribeOptions = buildTranscribeOptionsFromTranslate(options, translation, language_hints);
+		const transcription = await this.transcribe(transcribeOptions);
+		const job = new SonioxTranslationJob(transcription.toJSON(), this.http, mode, transcription.transcript);
+		if (!options.wait) return job;
+		if (job.status === "completed" && options.fetch_translation !== false) {
+			const translationResult = await job.getTranslation();
+			return new SonioxTranslationJob(job.toJSON(), this.http, mode, job.transcript, translationResult);
+		}
+		return new SonioxTranslationJob(job.toJSON(), this.http, mode, job.transcript, job.status === "error" ? null : void 0);
+	}
+	/**
 	* Permanently deletes all transcriptions.
 	* Iterates through all pages of transcriptions and deletes each one.
 	*
@@ -3360,6 +3757,93 @@ var SonioxSttApi = class {
 		}
 	}
 };
+const DEFAULT_TRANSLATE_MODEL = "stt-async-v4";
+/**
+* Resolve the caller-supplied {@link TranslateMode} into the underlying
+* `translation` config plus optional `language_hints`, and the reshape mode
+* descriptor passed to {@link translateFromTranscript}.
+*
+* The discriminated input type already enforces "exactly one of `to` /
+* `between`" at compile time. The runtime checks here are a defensive
+* backup for callers that bypass typings.
+*/
+function resolveTranslateMode(options) {
+	const between = options.between;
+	const to = options.to;
+	const from = options.from;
+	if (between !== void 0) {
+		if (to !== void 0) throw new Error("translate: cannot specify both \"to\" and \"between\"");
+		if (from !== void 0) throw new Error("translate: cannot specify \"from\" together with \"between\"");
+		if (!Array.isArray(between) || between.length !== 2) throw new Error("translate: \"between\" must be a [language_a, language_b] tuple");
+		const [language_a, language_b] = between;
+		if (!language_a || !language_b) throw new Error("translate: \"between\" languages must be non-empty strings");
+		return {
+			translation: {
+				type: "two_way",
+				language_a,
+				language_b
+			},
+			language_hints: [language_a, language_b],
+			mode: {
+				type: "two_way",
+				language_a,
+				language_b
+			}
+		};
+	}
+	if (to !== void 0) {
+		if (!to) throw new Error("translate: \"to\" must be a non-empty string");
+		if (from !== void 0 && !from) throw new Error("translate: \"from\" must be a non-empty string when provided");
+		return {
+			translation: {
+				type: "one_way",
+				target_language: to
+			},
+			language_hints: from !== void 0 ? [from] : void 0,
+			mode: from !== void 0 ? {
+				type: "one_way",
+				to,
+				from
+			} : {
+				type: "one_way",
+				to
+			}
+		};
+	}
+	throw new Error("translate: requires either \"to\" or \"between\"");
+}
+/**
+* Build the {@link TranscribeOptions} payload for `translate()` by stripping
+* the mode-only fields (`to` / `from` / `between`), applying the model
+* default, and pinning method-owned fields (`translation`, `language_hints`,
+* `language_hints_strict`, `enable_language_identification`).
+*
+* `enable_language_identification` is forced to `true` because the reshape
+* step depends on language-tagged transcript tokens.
+*/
+function buildTranscribeOptionsFromTranslate(options, translation, language_hints) {
+	const rest = { ...options };
+	delete rest.to;
+	delete rest.from;
+	delete rest.between;
+	delete rest.model;
+	delete rest.fetch_translation;
+	delete rest.fetch_transcript;
+	delete rest.language_hints;
+	delete rest.language_hints_strict;
+	const base = {
+		...rest,
+		model: options.model ?? DEFAULT_TRANSLATE_MODEL,
+		translation,
+		enable_language_identification: true,
+		fetch_transcript: options.wait && options.fetch_translation !== false ? true : false
+	};
+	if (language_hints !== void 0) {
+		base.language_hints = language_hints;
+		base.language_hints_strict = true;
+	}
+	return base;
+}
 
 //#endregion
 //#region src/async/tts.ts
@@ -3441,6 +3925,110 @@ var SonioxTtsApi = class extends TtsRestClient {
 	}
 };
 
+//#endregion
+//#region src/async/usage-logs.ts
+/**
+* Result set for usage log listing.
+*/
+var UsageLogListResult = class {
+	/**
+	* Usage logs from the first page of results.
+	*/
+	usage_logs;
+	/**
+	* Pagination cursor for the next page. Null if no more pages.
+	*/
+	next_page_cursor;
+	constructor(initialResponse, _http, _options) {
+		this._http = _http;
+		this._options = _options;
+		this.usage_logs = initialResponse.usage_logs;
+		this.next_page_cursor = initialResponse.next_page_cursor;
+	}
+	/**
+	* Returns the raw data for this list result.
+	*/
+	toJSON() {
+		return {
+			usage_logs: this.usage_logs,
+			next_page_cursor: this.next_page_cursor
+		};
+	}
+	/**
+	* Returns true if there are more pages of results beyond the first page.
+	*/
+	isPaged() {
+		return this.next_page_cursor !== null;
+	}
+	/**
+	* Async iterator that automatically fetches all pages.
+	* Use with `for await...of` to iterate through all usage logs.
+	*/
+	async *[Symbol.asyncIterator]() {
+		for (const usageLog of this.usage_logs) yield usageLog;
+		let cursor = this.next_page_cursor;
+		while (cursor !== null) {
+			const response = await this._http.request({
+				method: "GET",
+				path: "/v1/usage-logs",
+				query: {
+					start_time: this._options.start_time,
+					end_time: this._options.end_time,
+					limit: this._options.limit,
+					sort: this._options.sort,
+					cursor
+				},
+				...this._options.signal && { signal: this._options.signal }
+			});
+			for (const usageLog of response.data.usage_logs) yield usageLog;
+			cursor = response.data.next_page_cursor;
+		}
+	}
+};
+var SonioxUsageLogsAPI = class {
+	constructor(http) {
+		this.http = http;
+	}
+	/**
+	* Retrieves per-request usage log entries for the project.
+	*
+	* The returned result is async iterable. Use `for await...of` to iterate
+	* through all pages.
+	*
+	* @param options - Required time window plus optional pagination, sorting, and cancellation.
+	* @returns UsageLogListResult with async iteration support.
+	* @throws {@link SonioxHttpError} On API errors.
+	*
+	* @example
+	* ```typescript
+	* const result = await client.usageLogs.list({
+	*   start_time: '2026-04-28T09:00:00Z',
+	*   end_time: '2026-04-29T09:00:00Z',
+	*   sort: 'end_time_desc',
+	* });
+	*
+	* for await (const log of result) {
+	*   console.log(log.model, log.cost_usd);
+	* }
+	* ```
+	*/
+	async list(options) {
+		const { start_time, end_time, limit, sort, cursor, signal } = options;
+		return new UsageLogListResult((await this.http.request({
+			method: "GET",
+			path: "/v1/usage-logs",
+			query: {
+				start_time,
+				end_time,
+				limit,
+				sort,
+				cursor
+			},
+			...signal && { signal }
+		})).data, this.http, options);
+	}
+};
+
 //#endregion
 //#region src/async/webhooks.ts
 const VALID_STATUSES = ["completed", "error"];
@@ -4373,6 +4961,8 @@ var SonioxNodeClient = class {
 	models;
 	webhooks;
 	auth;
+	concurrencyLimits;
+	usageLogs;
 	realtime;
 	constructor(options = {}) {
 		const apiKey = options.api_key ?? process.env["SONIOX_API_KEY"];
@@ -4397,6 +4987,8 @@ var SonioxNodeClient = class {
 		this.models = new SonioxModelsAPI(http);
 		this.webhooks = new SonioxWebhooksAPI(this.stt);
 		this.auth = new SonioxAuthAPI(http);
+		this.concurrencyLimits = new SonioxConcurrencyLimitsAPI(http);
+		this.usageLogs = new SonioxUsageLogsAPI(http);
 		this.tts = new SonioxTtsApi(apiKey, options.tts_api_url ?? process.env["SONIOX_TTS_API_URL"] ?? regionDefaults.tts_api_url, http);
 		this.realtime = new SonioxRealtimeApi({
 			api_key: apiKey,
@@ -4434,6 +5026,7 @@ exports.SONIOX_TMP_API_KEY_DURATION_MIN = SONIOX_TMP_API_KEY_DURATION_MIN;
 exports.SONIOX_TMP_API_KEY_USAGE_TYPE = SONIOX_TMP_API_KEY_USAGE_TYPE;
 exports.SONIOX_TTS_API_BASE_URL = SONIOX_TTS_API_BASE_URL;
 exports.SONIOX_TTS_WS_URL = SONIOX_TTS_WS_URL;
+exports.SonioxConcurrencyLimitsAPI = SonioxConcurrencyLimitsAPI;
 exports.SonioxError = SonioxError;
 exports.SonioxFile = SonioxFile;
 exports.SonioxHttpError = SonioxHttpError;
@@ -4441,9 +5034,12 @@ exports.SonioxNodeClient = SonioxNodeClient;
 exports.SonioxRealtimeApi = SonioxRealtimeApi;
 exports.SonioxTranscript = SonioxTranscript;
 exports.SonioxTranscription = SonioxTranscription;
+exports.SonioxTranslationJob = SonioxTranslationJob;
 exports.SonioxTtsApi = SonioxTtsApi;
+exports.SonioxUsageLogsAPI = SonioxUsageLogsAPI;
 exports.StateError = StateError;
 exports.TranscriptionListResult = TranscriptionListResult;
+exports.UsageLogListResult = UsageLogListResult;
 exports.buildUrl = buildUrl;
 exports.createAbortError = createAbortError;
 exports.createHttpError = createHttpError;
@@ -4458,4 +5054,5 @@ exports.normalizeHeaders = normalizeHeaders;
 exports.resolveConnectionConfig = resolveConnectionConfig;
 exports.segmentRealtimeTokens = segmentRealtimeTokens;
 exports.segmentTranscript = segmentTranscript;
+exports.translateFromTranscript = translateFromTranscript;
 //# sourceMappingURL=index.cjs.map