@vocalstack/js-sdk 1.0.12

package/LICENSE

@@ -0,0 +1,21 @@
+VocalStack Proprietary License
+
+Copyright (C) 2024 VocalStack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use the Software solely in connection with the VocalStack service, subject to the following conditions:
+
+## Usage Limitations
+
+1. **Compliance with Terms of Service**: The Software must be used in a manner that does not violate the VocalStack terms of service ([https://www.vocalstack.com/terms-of-service](https://www.vocalstack.com/terms-of-service)).
+
+2. **Commercial Use Allowed**: The Licensed Work may be used for commercial purposes, provided the user has a valid API key and an active subscription to the VocalStack service. Unauthorized use is strictly prohibited.
+
+3. **Modification and Contributions**: You may view and modify the Licensed Work for internal use only. Contributions to the Licensed Work may be made through pull requests. By submitting a contribution, you agree to assign the rights of the contribution to VocalStack.
+
+4. **Redistribution Allowed**: Redistribution of the Software, in whole or in part, whether modified or unmodified, is permitted, provided that it does not violate the company's terms of service.
+
+5. **Termination**: VocalStack reserves the right to terminate your access to and use of the Software at any time if you fail to comply with these terms.
+
+## Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+[![](/logo.svg 'VocalStack')](https://vocalstack.com)
+
+> VocalStack is a platform that can be used for building voice applications. See more at [https://vocalstack.com](vocalstack.com).
+
+This repository contains the official VocalStack SDK for JavaScript. It provides a simple way
+to interact with the [VocalStack API](https://vocalstack.com/api).
+Most notably, it helps implement asynchronous bidirectional communication
+such as live stream transcriptions in just a few lines of code.
+This SDK will work in both Node.js and the browser.
+
+
+# Installation
+
+Before you start, install the VocalStack JavaScript SDK using your preferred Node package manager, such as npm:
+
+```bash
+npm install @vocalstack/js-sdk
+```
+
+Also make sure to have a [VocalStack account](https://vocalstack.com) and an API key, which you can generate
+at https://vocalstack.com/dashboard/api-keys.
+There is a free tier available, so you can start experimenting right away.
+
+
+# Quick Example
+
+Here is a quick example of how to use the SDK to transcribe a file from a URL:
+```javascript
+import { UrlTranscription } from '@vocalstack/js-sdk';
+
+const sdk = new UrlTranscription({ apiKey: 'YOUR-API-KEY' });
+const transcription = await sdk.connect({
+  url: 'http://example.com/files/meaningless.mp3',
+});
+
+transcription.start();
+
+// This will print the transcription data as it comes in
+transcription.onData(console.log);
+
+/*
+{
+  status: 'processing',
+  data: {
+    id: 'd1e7b3b0-7b3b-4b3b-8b3b-0b3b7b3b3b3b',
+    operation: 'transcription-prerecorded',
+    progress: 0.1,
+    timeline: [
+      {
+        start: 0,
+        end: 7.52,
+        text: 'Meaningless, meaningless, says the teacher, utterly meaningless, everything is meaningless.',
+        language: 'en',
+        translations: { ... },
+      },
+      ...
+    ]
+  }
+}
+*/
+```
+
+
+# Documentation Index
+
+- [Transcribe Audio from URL](https://github.com/vocalstack/js-sdk/blob/main/documentation/transcribe-audio-from-url-to-text.md): 
+Transcribe speech from pre-recorded audio in a URL to plain text. Major file formats are supported, including MP3, WAV, FLAC, and OGG.
+
+- [Transcribe from a Microphone or LiveStream](https://github.com/vocalstack/js-sdk/blob/main/documentation/transcribe-from-a-microphone-or-live-stream.md): 
+Transcribe live speech from a microphone or live stream. Integrate with Polyglot to create a public shareable link for the transcription which users can read in any language. 
+
+- [Transcribe and Present a Polyglot Session](https://github.com/vocalstack/js-sdk/blob/main/documentation/transcribe-and-present-a-polyglot-session.md): 
+Create a session that can be used to broadcast a live transcription via a public shareable link. Users can read live transcriptions in their preferred language, and even past transcriptions when your session is inactive.
+
+- [Translate a Transcription](https://github.com/vocalstack/js-sdk/blob/main/documentation/translate-transcription-to-another-language.md): 
+Translate transcribed text to another language. This can be done for any transcription, including prerecorded transcriptions, live transcriptions or Polyglot session transcriptions.
+
+- [Get Transcription Data](https://github.com/vocalstack/js-sdk/blob/main/documentation/get-transcription-data.md): 
+Get data from pending or completed transcriptions. This includes the transcription timeline, key words, summary, and paragraph segments.
+
+- [Client Side Authentication Tokens](https://github.com/vocalstack/js-sdk/blob/main/documentation/transcribe-on-the-front-end-with-auth-tokens.md): 
+Create a temporary authentication token for client side requests. Safely implement API requests in web browsers without exposing your API keys.
+
+- [Transcription Sessions](https://github.com/vocalstack/js-sdk/blob/main/documentation/transcription-sessions.md): 
+Monitor and manage transcription state with sessions. Using sessions you can reconnect to a previously created asynchronous connection.
+
+- [Transcription Request and Response](https://github.com/vocalstack/js-sdk/blob/main/documentation/transcription-request-and-response.md): 
+Common request options and responses for all transcription operations. Use options to configure the transcription settings.
+

package/dist/RestApi.d.ts

@@ -0,0 +1,21 @@
+export type ApiResponse<T> = {
+    status: 'waiting' | 'processing' | 'done' | 'error';
+    data?: null | T;
+    success: boolean;
+    error?: string;
+};
+export type RequestOptions = RequestInit & {
+    json?: Record<string, unknown>;
+};
+export declare class RestApi {
+    private apiServer;
+    private headers;
+    constructor(apiServer: string, headers: Record<string, string>);
+    get<T>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    post<T>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    put<T>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    patch<T>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    delete<T>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    private apiCall;
+    private respond;
+}

package/dist/RestApi.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestApi = void 0;
+class RestApi {
+    constructor(apiServer, headers) {
+        this.apiServer = apiServer;
+        this.headers = headers;
+    }
+    get(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiCall('GET', path, options);
+        });
+    }
+    post(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiCall('POST', path, options);
+        });
+    }
+    put(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiCall('PUT', path, options);
+        });
+    }
+    patch(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiCall('PATCH', path, options);
+        });
+    }
+    delete(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiCall('DELETE', path, options);
+        });
+    }
+    apiCall(method, path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const fixedPath = path.startsWith('/') ? path.slice(1) : path;
+                const _a = options || {}, { json } = _a, fetchOptions = __rest(_a, ["json"]);
+                const body = json ? JSON.stringify(json) : undefined;
+                const headers = Object.assign({}, this.headers);
+                if (body) {
+                    headers['Content-Type'] = 'application/json';
+                }
+                const response = yield fetch(`${this.apiServer}/${fixedPath}`, Object.assign({ method,
+                    headers,
+                    body }, fetchOptions));
+                return this.respond(response);
+            }
+            catch (e) {
+                console.log(e);
+                return {
+                    success: false,
+                    error: String(e),
+                    status: 'error',
+                    data: undefined,
+                };
+            }
+        });
+    }
+    respond(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const success = response.ok;
+            const json = success ? yield response.json() : undefined;
+            const data = Object.assign({ success, error: !success ? response.statusText : undefined }, json);
+            if ((data === null || data === void 0 ? void 0 : data.status) === 'error') {
+                data.error = 'An error occurred while processing the request.';
+                data.success = false;
+            }
+            return data;
+        });
+    }
+}
+exports.RestApi = RestApi;

package/dist/VocalStackApi.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ApiResponse, RestApi } from './RestApi';
+import { WebSocketsApi } from './WebsocketApi';
+import { Configuration } from './generics.zod';
+export declare const VOCALSTACK_API_SERVER = "https://api.vocalstack.com";
+export declare class VocalStackApi {
+    protected headers: Record<string, string>;
+    protected apiServer: string;
+    constructor(config: Configuration);
+    protected _rest(): RestApi;
+    protected _ws(): WebSocketsApi;
+    private buildConfiguration;
+    protected withValidation(zodType: z.ZodType, data: unknown): {
+        success: boolean;
+        badResponse: ApiResponse<null> | undefined;
+        data: any;
+    };
+    protected buildQueryString(params: Record<string, undefined | string | number | boolean>): string;
+}

package/dist/VocalStackApi.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VocalStackApi = exports.VOCALSTACK_API_SERVER = void 0;
+const RestApi_1 = require("./RestApi");
+const WebsocketApi_1 = require("./WebsocketApi");
+const generics_zod_1 = require("./generics.zod");
+exports.VOCALSTACK_API_SERVER = 'https://api.vocalstack.com';
+class VocalStackApi {
+    constructor(config) {
+        const { apiServer, headers } = this.buildConfiguration(config);
+        this.apiServer = apiServer;
+        this.headers = headers;
+    }
+    _rest() {
+        return new RestApi_1.RestApi(this.apiServer, this.headers);
+    }
+    _ws() {
+        return new WebsocketApi_1.WebSocketsApi(this.apiServer, this.headers);
+    }
+    buildConfiguration(config) {
+        const parsedConfiguration = generics_zod_1.zConfiguration.safeParse(config);
+        if (!parsedConfiguration.success) {
+            throw new Error(parsedConfiguration.error.errors.map((err) => err.message).join(', '));
+        }
+        const data = parsedConfiguration.data;
+        return Object.assign(Object.assign({}, data), { apiServer: data.apiServer || exports.VOCALSTACK_API_SERVER, headers: Object.assign(Object.assign({}, data.headers), { authorization: data.authToken ? `Bearer ${data.authToken}` : data.apiKey || '' }) });
+    }
+    withValidation(zodType, data) {
+        const parsedRequest = zodType.safeParse(data);
+        return {
+            success: parsedRequest.success,
+            badResponse: parsedRequest.success
+                ? undefined
+                : {
+                    status: 'error',
+                    data: null,
+                    success: false,
+                    error: parsedRequest.error.errors.map((err) => err.message).join(', '),
+                },
+            data: parsedRequest.success ? parsedRequest.data : null,
+        };
+    }
+    buildQueryString(params) {
+        return Object.entries(params)
+            .filter(([, value]) => value !== undefined && value !== null && value !== '')
+            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+            .join('&');
+    }
+}
+exports.VocalStackApi = VocalStackApi;

package/dist/WebsocketApi.d.ts

@@ -0,0 +1,38 @@
+export interface WebsocketRequestOptions {
+    path: string;
+    mustStart?: boolean;
+    headers?: Record<string, string>;
+}
+export type WebsocketConnection<ResponseType> = {
+    start: () => void;
+    close: () => void;
+    onClose: (callback: () => void) => void;
+    onData: (callback: (ev: ResponseType) => void) => void;
+};
+export type DuplexWebsocketConnection<RequestType, ResponseType> = WebsocketConnection<ResponseType> & {
+    stop: () => void;
+    sendBuffer: (message: RequestType) => void;
+};
+export declare class WebSocketsApi {
+    private apiServer;
+    private headers;
+    private socket;
+    private WebSocketClass;
+    private started;
+    private session;
+    constructor(apiServer: string, headers: Record<string, string>);
+    private makeSocketConnection;
+    connect<ResponseType>(options: WebsocketRequestOptions): Promise<{
+        start: () => void;
+        close: () => void;
+        onClose: (callback: () => void) => void;
+        onData: (callback: (ev: ResponseType) => void) => void;
+    }>;
+    connectDuplex<RequestType, ResponseType>(options: WebsocketRequestOptions): Promise<DuplexWebsocketConnection<RequestType, ResponseType>>;
+    private returnConnection;
+    private returnDuplexConnection;
+    private sendBuffer;
+    private onMessage;
+    private onClose;
+    private close;
+}

package/dist/WebsocketApi.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketsApi = void 0;
+class WebSocketsApi {
+    constructor(apiServer, headers) {
+        this.apiServer = apiServer;
+        this.headers = headers;
+        this.socket = undefined;
+        this.WebSocketClass = undefined;
+        this.started = false;
+        if (typeof window !== 'undefined') {
+            // Browser environment: use native WebSocket
+            this.WebSocketClass = window.WebSocket;
+        }
+        else if (typeof globalThis.WebSocket !== 'undefined') {
+            // Node.js environment: use global WebSocket if available (e.g., Node 22+)
+            this.WebSocketClass = globalThis.WebSocket;
+        }
+        else {
+            // Node.js environment: use "ws" package where WebSocket is not available
+            console.log('!!!!!!!');
+            console.log('!!!!!!!');
+            console.log('!!!!!!!');
+            console.log('!!!!!!!');
+            console.log('!!!!!!!');
+            console.log('!!!!!!!');
+            this.WebSocketClass = require('ws').WebSocket;
+        }
+    }
+    makeSocketConnection(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve, reject) => {
+                const base = this.apiServer.replace('https://', 'wss://').replace('http://', 'ws://');
+                const url = `${base}${options.path}`;
+                const headers = Object.assign(Object.assign(Object.assign({}, this.headers), options.headers), { path: options.path });
+                if (!this.WebSocketClass) {
+                    throw Error('WebSocket class was not loaded.');
+                }
+                const socket = new this.WebSocketClass(url);
+                this.socket = socket;
+                if (!this.socket) {
+                    throw Error('Failed to create WebSocket connection');
+                }
+                socket.onopen = () => {
+                    socket.send(JSON.stringify({ headers, session: this.session }));
+                    if (!options.mustStart) {
+                        resolve();
+                        return;
+                    }
+                    socket.addEventListener('message', (event) => {
+                        const data = JSON.parse(event.data.toString());
+                        if (data === null || data === void 0 ? void 0 : data.session) {
+                            resolve();
+                        }
+                    });
+                };
+                socket.onerror = (error) => {
+                    console.error('WebSocket error:', error);
+                    reject('A websocket error occurred connecting to the VocalStack API');
+                };
+                socket.addEventListener('message', (event) => {
+                    var _a;
+                    const data = JSON.parse(event.data.toString());
+                    if (data === null || data === void 0 ? void 0 : data.session) {
+                        this.session = data.session;
+                    }
+                    if ((data === null || data === void 0 ? void 0 : data.status) === 'done') {
+                        (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close();
+                    }
+                });
+            });
+        });
+    }
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.makeSocketConnection(options);
+            return this.returnConnection();
+        });
+    }
+    connectDuplex(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.makeSocketConnection(Object.assign(Object.assign({}, options), { mustStart: true }));
+            return this.returnDuplexConnection();
+        });
+    }
+    returnConnection() {
+        return {
+            start: () => {
+                if (!this.socket) {
+                    console.error('Socket not connected');
+                    return;
+                }
+                if (this.started) {
+                    console.error('Already started');
+                    return;
+                }
+                this.started = true;
+                this.socket.send(JSON.stringify({ start: true, session: this.session }));
+            },
+            close: () => this.close(),
+            onClose: (callback) => this.onClose(callback),
+            onData: (callback) => this.onMessage(callback),
+        };
+    }
+    returnDuplexConnection() {
+        return Object.assign(Object.assign({}, this.returnConnection()), { stop: () => !this.socket
+                ? console.error('Socket not connected')
+                : this.socket.send(JSON.stringify({ stop: true, session: this.session })), sendBuffer: (message) => this.sendBuffer(message) });
+    }
+    sendBuffer(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.socket || this.socket.readyState !== ((_a = this.WebSocketClass) === null || _a === void 0 ? void 0 : _a.OPEN)) {
+                throw Error('WebSocket is not connected.');
+            }
+            if (!(buffer instanceof ArrayBuffer) && !ArrayBuffer.isView(buffer)) {
+                throw Error('Unexpected data type being sent. Expected: ArrayBuffer or ArrayBufferView');
+            }
+            else {
+                this.socket.send(buffer);
+            }
+        });
+    }
+    onMessage(callback) {
+        if (!this.socket) {
+            throw Error('WebSocket is not connected.');
+        }
+        this.socket.addEventListener('message', (event) => {
+            const data = JSON.parse(event.data.toString());
+            callback(data);
+        });
+    }
+    onClose(callback) {
+        if (!this.socket) {
+            throw Error('WebSocket is not connected.');
+        }
+        this.socket.addEventListener('close', callback);
+    }
+    close() {
+        if (!this.socket) {
+            console.error('WebSocket is not connected.');
+            return;
+        }
+        this.socket.close();
+    }
+}
+exports.WebSocketsApi = WebSocketsApi;

package/dist/apis/Billing.d.ts

@@ -0,0 +1,59 @@
+import { VocalStackApi } from '../VocalStackApi';
+import { SummaryTranscription } from './Transcriptions';
+export type BillingDetailsPlan = {
+    uuid: string;
+    start_date: string;
+    stop_date: string;
+    price: number;
+    billing_frequency: string;
+    free_hours: number;
+    overage_rate_prerecorded: number;
+    overage_rate_live: number;
+    meta_name: string;
+};
+export type BillingDetails = {
+    balance: number;
+    prerecorded_hours_available: number;
+    live_hours_available: number;
+    free_hours_used: number;
+    free_hours_left: number;
+    total_per_month: Record<string, number>;
+    savings_per_month: Record<string, number>;
+    paid_per_month: Record<string, number>;
+    owed_per_month: Record<string, number>;
+    plans: BillingDetailsPlan[];
+    active_plan: BillingDetailsPlan;
+    hobby_plan: BillingDetailsPlan;
+    month_plans: Record<string, string[]>;
+    billing: Record<string, Array<Partial<SummaryTranscription> & {
+        plan: string;
+        length_in_adjusted_seconds: number;
+        free_seconds_available_before?: number;
+        free_seconds_available_after?: number;
+        cost: number;
+        notes: string[];
+    }>>;
+    invoices: Array<{
+        invoice_id: string;
+        plan_id?: string;
+        plan_uuid?: string;
+        interval?: 'year' | 'month';
+        status: 'open' | 'paid' | 'void';
+        status_transitions: {
+            paid_at: number;
+            finalized_at: number;
+            marked_uncollectible_at: number;
+            voided_at: number;
+        };
+        paid: boolean;
+        amount: number;
+        amount_paid: number;
+        amount_remaining: number;
+        view_link: string;
+        download_link: string;
+        metadata?: Record<string, string>;
+    }>;
+};
+export declare class Billing extends VocalStackApi {
+    getBillingDetails(): Promise<import("../RestApi").ApiResponse<BillingDetails>>;
+}

package/dist/apis/Billing.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Billing = void 0;
+const VocalStackApi_1 = require("../VocalStackApi");
+class Billing extends VocalStackApi_1.VocalStackApi {
+    getBillingDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._rest().get('/billing/details');
+        });
+    }
+}
+exports.Billing = Billing;

package/dist/apis/LiveTranscription.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { Timeline, Uuid } from '../generics.zod';
+import { VocalStackApi } from '../VocalStackApi';
+import { DuplexWebsocketConnection } from '../WebsocketApi';
+import { Status } from './Transcriptions';
+declare const zLiveTranscriptionStartRequest: z.ZodObject<{
+    livestream_url: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodEnum<["af", "am", "an", "ar", "as", "az", "be", "bg", "bn", "br", "bs", "ca", "cs", "cy", "da", "de", "dz", "el", "en", "eo", "es", "et", "eu", "fa", "fi", "fo", "fr", "ga", "gl", "gu", "he", "hi", "hr", "ht", "hu", "hy", "id", "is", "it", "ja", "jv", "ka", "kk", "km", "kn", "ko", "ku", "ky", "la", "lb", "lo", "lt", "lv", "mg", "mk", "ml", "mn", "mr", "ms", "mt", "nb", "ne", "nl", "nn", "no", "oc", "or", "pa", "pl", "ps", "pt", "qu", "ro", "ru", "rw", "se", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "ug", "uk", "ur", "vi", "vo", "wa", "xh", "zh", "zu"]>>;
+    translations: z.ZodOptional<z.ZodArray<z.ZodEnum<["af", "am", "an", "ar", "as", "az", "be", "bg", "bn", "br", "bs", "ca", "cs", "cy", "da", "de", "dz", "el", "en", "eo", "es", "et", "eu", "fa", "fi", "fo", "fr", "ga", "gl", "gu", "he", "hi", "hr", "ht", "hu", "hy", "id", "is", "it", "ja", "jv", "ka", "kk", "km", "kn", "ko", "ku", "ky", "la", "lb", "lo", "lt", "lv", "mg", "mk", "ml", "mn", "mr", "ms", "mt", "nb", "ne", "nl", "nn", "no", "oc", "or", "pa", "pl", "ps", "pt", "qu", "ro", "ru", "rw", "se", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "ug", "uk", "ur", "vi", "vo", "wa", "xh", "zh", "zu"]>, "many">>;
+    polyglot_id: z.ZodOptional<z.ZodString>;
+    timeout_period_s: z.ZodOptional<z.ZodNumber>;
+    max_duration_s: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    language?: "id" | "cy" | "br" | "hr" | "th" | "tr" | "mn" | "ms" | "or" | "af" | "am" | "an" | "ar" | "as" | "az" | "be" | "bg" | "bn" | "bs" | "ca" | "cs" | "da" | "de" | "dz" | "el" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "fi" | "fo" | "fr" | "ga" | "gl" | "gu" | "he" | "hi" | "ht" | "hu" | "hy" | "is" | "it" | "ja" | "jv" | "ka" | "kk" | "km" | "kn" | "ko" | "ku" | "ky" | "la" | "lb" | "lo" | "lt" | "lv" | "mg" | "mk" | "ml" | "mr" | "mt" | "nb" | "ne" | "nl" | "nn" | "no" | "oc" | "pa" | "pl" | "ps" | "pt" | "qu" | "ro" | "ru" | "rw" | "se" | "si" | "sk" | "sl" | "sq" | "sr" | "sv" | "sw" | "ta" | "te" | "tl" | "ug" | "uk" | "ur" | "vi" | "vo" | "wa" | "xh" | "zh" | "zu" | undefined;
+    translations?: ("id" | "cy" | "br" | "hr" | "th" | "tr" | "mn" | "ms" | "or" | "af" | "am" | "an" | "ar" | "as" | "az" | "be" | "bg" | "bn" | "bs" | "ca" | "cs" | "da" | "de" | "dz" | "el" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "fi" | "fo" | "fr" | "ga" | "gl" | "gu" | "he" | "hi" | "ht" | "hu" | "hy" | "is" | "it" | "ja" | "jv" | "ka" | "kk" | "km" | "kn" | "ko" | "ku" | "ky" | "la" | "lb" | "lo" | "lt" | "lv" | "mg" | "mk" | "ml" | "mr" | "mt" | "nb" | "ne" | "nl" | "nn" | "no" | "oc" | "pa" | "pl" | "ps" | "pt" | "qu" | "ro" | "ru" | "rw" | "se" | "si" | "sk" | "sl" | "sq" | "sr" | "sv" | "sw" | "ta" | "te" | "tl" | "ug" | "uk" | "ur" | "vi" | "vo" | "wa" | "xh" | "zh" | "zu")[] | undefined;
+    livestream_url?: string | undefined;
+    polyglot_id?: string | undefined;
+    timeout_period_s?: number | undefined;
+    max_duration_s?: number | undefined;
+}, {
+    language?: "id" | "cy" | "br" | "hr" | "th" | "tr" | "mn" | "ms" | "or" | "af" | "am" | "an" | "ar" | "as" | "az" | "be" | "bg" | "bn" | "bs" | "ca" | "cs" | "da" | "de" | "dz" | "el" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "fi" | "fo" | "fr" | "ga" | "gl" | "gu" | "he" | "hi" | "ht" | "hu" | "hy" | "is" | "it" | "ja" | "jv" | "ka" | "kk" | "km" | "kn" | "ko" | "ku" | "ky" | "la" | "lb" | "lo" | "lt" | "lv" | "mg" | "mk" | "ml" | "mr" | "mt" | "nb" | "ne" | "nl" | "nn" | "no" | "oc" | "pa" | "pl" | "ps" | "pt" | "qu" | "ro" | "ru" | "rw" | "se" | "si" | "sk" | "sl" | "sq" | "sr" | "sv" | "sw" | "ta" | "te" | "tl" | "ug" | "uk" | "ur" | "vi" | "vo" | "wa" | "xh" | "zh" | "zu" | undefined;
+    translations?: ("id" | "cy" | "br" | "hr" | "th" | "tr" | "mn" | "ms" | "or" | "af" | "am" | "an" | "ar" | "as" | "az" | "be" | "bg" | "bn" | "bs" | "ca" | "cs" | "da" | "de" | "dz" | "el" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "fi" | "fo" | "fr" | "ga" | "gl" | "gu" | "he" | "hi" | "ht" | "hu" | "hy" | "is" | "it" | "ja" | "jv" | "ka" | "kk" | "km" | "kn" | "ko" | "ku" | "ky" | "la" | "lb" | "lo" | "lt" | "lv" | "mg" | "mk" | "ml" | "mr" | "mt" | "nb" | "ne" | "nl" | "nn" | "no" | "oc" | "pa" | "pl" | "ps" | "pt" | "qu" | "ro" | "ru" | "rw" | "se" | "si" | "sk" | "sl" | "sq" | "sr" | "sv" | "sw" | "ta" | "te" | "tl" | "ug" | "uk" | "ur" | "vi" | "vo" | "wa" | "xh" | "zh" | "zu")[] | undefined;
+    livestream_url?: string | undefined;
+    polyglot_id?: string | undefined;
+    timeout_period_s?: number | undefined;
+    max_duration_s?: number | undefined;
+}>;
+export type LiveTranscriptionStartRequest = z.infer<typeof zLiveTranscriptionStartRequest>;
+export type LiveTranscriptionStreamData = ArrayBufferLike;
+export type LiveTranscriptionResponse = {
+    status: Status;
+    data: LiveTranscriptionResponseData | null;
+    http_code?: number;
+};
+export type LiveTranscriptionResponseData = {
+    id: Uuid;
+    polyglot_id: Uuid | null;
+    start: string;
+    end: string | null;
+    status: Status;
+    operation: 'transcription-live';
+    flags?: {
+        started: boolean;
+    } | null;
+    keywords?: string | null;
+    timeline?: Timeline;
+    paragraphs?: string[] | null;
+    summary?: string | null;
+};
+export type LiveTranscriptionStopRequest = {
+    id: string;
+};
+export type LiveTranscriptionConnection = DuplexWebsocketConnection<LiveTranscriptionStreamData, LiveTranscriptionResponse>;
+export declare class LiveTranscription extends VocalStackApi {
+    connect(request?: LiveTranscriptionStartRequest): Promise<LiveTranscriptionConnection>;
+    stopTranscribing({ id }: LiveTranscriptionStopRequest): Promise<import("../RestApi").ApiResponse<unknown>>;
+}
+export {};