@vocalstack/js-sdk 1.0.12

package/dist/apis/LiveTranscription.js

@@ -0,0 +1,55 @@
+"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.LiveTranscription = void 0;
+const zod_1 = require("zod");
+const generics_zod_1 = require("../generics.zod");
+const VocalStackApi_1 = require("../VocalStackApi");
+const zLiveTranscriptionStartRequest = zod_1.z.object({
+    livestream_url: zod_1.z.string().optional(),
+    language: generics_zod_1.zLanguage.optional(),
+    translations: generics_zod_1.zLanguage.array().optional(),
+    polyglot_id: zod_1.z.string().optional(),
+    timeout_period_s: zod_1.z.number().optional(),
+    max_duration_s: zod_1.z.number().optional(),
+});
+class LiveTranscription extends VocalStackApi_1.VocalStackApi {
+    connect() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            var _a;
+            const validation = this.withValidation(zLiveTranscriptionStartRequest, request);
+            if (validation.badResponse) {
+                throw new Error(validation.badResponse.error);
+            }
+            const headers = {};
+            if (request['livestream_url'] && request['livestream_url'] !== 'undefined') {
+                headers['livestream-url'] = request.livestream_url;
+            }
+            const queryString = this.buildQueryString({
+                polyglot_id: request.polyglot_id,
+                language: request.language,
+                translations: (_a = request.translations) === null || _a === void 0 ? void 0 : _a.join(','),
+                timeout_period_s: request.timeout_period_s,
+                max_duration_s: request.max_duration_s,
+            });
+            return this._ws().connectDuplex({
+                path: `/async/live/transcribe?${queryString}`,
+                headers,
+            });
+        });
+    }
+    stopTranscribing(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return this._rest().patch(`/live/transcribe/${id}/stop`);
+        });
+    }
+}
+exports.LiveTranscription = LiveTranscription;

package/dist/apis/Polyglot.d.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+import { Language, Timeline, Uuid } from '../generics.zod';
+import { ApiResponse } from '../RestApi';
+import { VocalStackApi } from '../VocalStackApi';
+import { WebsocketConnection } from '../WebsocketApi';
+import { SummaryTranscriptions } from './Transcriptions';
+export declare const zPolyglotSession: z.ZodObject<{
+    name: z.ZodString;
+    link: z.ZodString;
+    password: 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"]>>;
+    max_duration_s: z.ZodOptional<z.ZodNumber>;
+    timeout_period_s: z.ZodOptional<z.ZodNumber>;
+    livestream_url: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    link: string;
+    name: string;
+    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;
+    livestream_url?: string | undefined;
+    timeout_period_s?: number | undefined;
+    max_duration_s?: number | undefined;
+    password?: string | undefined;
+}, {
+    link: string;
+    name: string;
+    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;
+    livestream_url?: string | undefined;
+    timeout_period_s?: number | undefined;
+    max_duration_s?: number | undefined;
+    password?: string | undefined;
+}>;
+export type PolyglotSessionRequest = {
+    id?: string;
+    password?: string;
+    name: string;
+    link: string;
+    language: Language | null;
+    max_duration_s: number | null;
+    timeout_period_s: number | null;
+    livestream_url: string | null;
+};
+export type PolyglotSession = {
+    id: string;
+    name: string;
+    link: string;
+    fullUrl: string;
+    is_public: boolean;
+    requests: SummaryTranscriptions;
+    language: Language | null;
+    max_duration_s: number | null;
+    timeout_period_s: number | null;
+    livestream_url: string | null;
+};
+export type PolyglotCreatedSession = {
+    id: string;
+    link: string;
+};
+export type PolyglotUpdatedSession = {
+    id: string;
+    link: string;
+};
+export type PolyglotGetSessionResponse = ApiResponse<PolyglotSession>;
+export type PolyglotGetAllSessionsResponse = ApiResponse<PolyglotSession[]>;
+export type PolyglotDeleteSessionResponse = ApiResponse<null>;
+export type PolyglotCreateSessionResponse = ApiResponse<PolyglotCreatedSession>;
+export type PolyglotUpdateSessionResponse = ApiResponse<PolyglotUpdatedSession>;
+export type PolyglotPresenterRequest = {
+    link: string;
+    password?: string;
+};
+export type PolyglotPresenterResponse = {
+    status: string;
+    data: {
+        session: PolyglotPresenterSession;
+        activeTranscription: PolyglotPresenterTranscription;
+    };
+    http_code?: number;
+    error?: string;
+};
+export type PolyglotPresenterConnection = WebsocketConnection<PolyglotPresenterResponse>;
+export type PolyglotPresenterSession = {
+    id: Uuid;
+    name: string;
+    link: string;
+    fullUrl: string;
+    is_public: boolean;
+    requests: PolyglotPresenterTranscription[];
+};
+export type PolyglotPresenterTranscription = {
+    id: Uuid;
+    polyglot_id: Uuid | null;
+    start: string;
+    end: string | null;
+    status: 'waiting' | 'processing' | 'done' | 'error';
+    operation: 'transcription-live';
+    flags?: {
+        started: boolean;
+    } | null;
+    timeline?: Timeline;
+    keywords?: string | null;
+};
+export declare class Polyglot extends VocalStackApi {
+    getSession({ id }: {
+        id: string;
+    }): Promise<PolyglotGetSessionResponse>;
+    getAllSessions(): Promise<PolyglotGetAllSessionsResponse>;
+    deleteSession({ id }: {
+        id: string;
+    }): Promise<PolyglotDeleteSessionResponse>;
+    createSession(session: PolyglotSessionRequest): Promise<PolyglotCreateSessionResponse>;
+    updateSession(session: PolyglotSessionRequest): Promise<PolyglotUpdateSessionResponse>;
+    getLiveSessionStream({ link, password }: PolyglotPresenterRequest): Promise<PolyglotPresenterConnection>;
+}

package/dist/apis/Polyglot.js

@@ -0,0 +1,68 @@
+"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.Polyglot = exports.zPolyglotSession = void 0;
+const zod_1 = require("zod");
+const generics_zod_1 = require("../generics.zod");
+const VocalStackApi_1 = require("../VocalStackApi");
+exports.zPolyglotSession = zod_1.z.object({
+    name: zod_1.z.string(),
+    link: zod_1.z.string(),
+    password: zod_1.z.string().optional(),
+    language: generics_zod_1.zLanguage.optional(),
+    max_duration_s: zod_1.z.number().optional(),
+    timeout_period_s: zod_1.z.number().optional(),
+    livestream_url: zod_1.z.string().optional(),
+});
+class Polyglot extends VocalStackApi_1.VocalStackApi {
+    getSession(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return this._rest().get(`/polyglot/${id}`);
+        });
+    }
+    getAllSessions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._rest().get('/polyglot');
+        });
+    }
+    deleteSession(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return this._rest().delete(`/polyglot/${id}`);
+        });
+    }
+    createSession(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validation = this.withValidation(exports.zPolyglotSession, session);
+            return (validation.badResponse ||
+                this._rest().post('/polyglot', {
+                    json: validation.data,
+                }));
+        });
+    }
+    updateSession(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validation = this.withValidation(exports.zPolyglotSession, session);
+            return (validation.badResponse ||
+                this._rest().put(`/polyglot/${session.id}`, {
+                    json: validation.data,
+                }));
+        });
+    }
+    getLiveSessionStream(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ link, password }) {
+            return this._ws().connect({
+                path: `/async/polyglot/${link}`,
+                headers: { password: !password ? '' : password },
+            });
+        });
+    }
+}
+exports.Polyglot = Polyglot;

package/dist/apis/Security.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { VocalStackApi } from '../VocalStackApi';
+import { ApiResponse } from '../RestApi';
+declare const zGenerateTokenRequest: z.ZodObject<{
+    access: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"readonly">, z.ZodLiteral<"readwrite">]>>;
+    lifetime_s: z.ZodOptional<z.ZodNumber>;
+    one_time: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    access?: "readonly" | "readwrite" | undefined;
+    lifetime_s?: number | undefined;
+    one_time?: boolean | undefined;
+}, {
+    access?: "readonly" | "readwrite" | undefined;
+    lifetime_s?: number | undefined;
+    one_time?: boolean | undefined;
+}>;
+type GenerateTokenRequest = z.infer<typeof zGenerateTokenRequest>;
+export type GenerateTokenResponse = {
+    status: 'done' | 'error';
+    data: string;
+};
+export declare class Security extends VocalStackApi {
+    generateToken(request?: GenerateTokenRequest): Promise<ApiResponse<GenerateTokenResponse>>;
+}
+export {};

package/dist/apis/Security.js

@@ -0,0 +1,35 @@
+"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.Security = void 0;
+const zod_1 = require("zod");
+const VocalStackApi_1 = require("../VocalStackApi");
+const zGenerateTokenRequest = zod_1.z.object({
+    access: zod_1.z.union([zod_1.z.literal('readonly'), zod_1.z.literal('readwrite')]).optional(),
+    lifetime_s: zod_1.z.optional(zod_1.z.number().gt(0).lte(120)),
+    one_time: zod_1.z.optional(zod_1.z.boolean()),
+});
+class Security extends VocalStackApi_1.VocalStackApi {
+    generateToken(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof window !== 'undefined') {
+                return Promise.resolve({
+                    success: false,
+                    error: 'Cannot generate token in a browser window. Please use a server environment.',
+                    status: 'error',
+                    data: null,
+                });
+            }
+            return this._rest().get(`/security/generate-token?${this.buildQueryString(request || {})}`);
+        });
+    }
+}
+exports.Security = Security;

package/dist/apis/Transcriptions.d.ts

@@ -0,0 +1,61 @@
+import { Language, Timeline, Uuid } from '../generics.zod';
+import { VocalStackApi } from '../VocalStackApi';
+import { ApiResponse } from '../RestApi';
+import { WebsocketConnection } from '../WebsocketApi';
+export type { Timeline };
+export type Operation = 'transcription-prerecorded' | 'transcription-live';
+export type Status = 'waiting' | 'processing' | 'done' | 'stopping' | 'error';
+export type FinishedTranscription = {
+    id: Uuid;
+    status: Status;
+    operation: Operation;
+    start: string;
+    end?: string;
+    keywords?: string | null;
+    timeline: Timeline;
+    paragraphs?: string[] | null;
+    summary?: string | null;
+    url?: string;
+    duration: number;
+};
+export type SummaryTranscription = {
+    id: string;
+    operation: Operation;
+    status: Status;
+    duration?: number;
+    start: string;
+    end: string | null;
+    polyglot_id: string;
+    url?: string;
+    keywords: string | null;
+};
+export type SummaryTranscriptions = SummaryTranscription[];
+export type FinishedTranscriptionRequest = {
+    id: string;
+};
+export type FinishedTranscriptionResponse = ApiResponse<FinishedTranscription>;
+export type AllTranscriptionsResponse = ApiResponse<SummaryTranscriptions>;
+export type AddTranscriptionTranslationRequest = {
+    id: string;
+    language: Language;
+};
+export type AddTranslationResponse = ApiResponse<{
+    timeline: Timeline;
+}>;
+export type RemoveTranscriptionTranslationRequest = {
+    id: string;
+    language: Language;
+};
+export type RemoveTranslationResponse = ApiResponse<null>;
+export type AddTranscriptionTranslationAsyncResponse = {
+    status: Status;
+    data: FinishedTranscription | null;
+};
+export type AddTranscriptionTranslationConnection = WebsocketConnection<AddTranscriptionTranslationAsyncResponse>;
+export declare class Transcriptions extends VocalStackApi {
+    getTranscription({ id }: FinishedTranscriptionRequest): Promise<FinishedTranscriptionResponse>;
+    getAllTranscriptions(): Promise<AllTranscriptionsResponse>;
+    addTranslation({ id, language }: AddTranscriptionTranslationRequest): Promise<AddTranslationResponse>;
+    removeTranslation(req: RemoveTranscriptionTranslationRequest): Promise<RemoveTranslationResponse>;
+    addTranslationAsync(req: AddTranscriptionTranslationRequest): Promise<AddTranscriptionTranslationConnection>;
+}

package/dist/apis/Transcriptions.js

@@ -0,0 +1,43 @@
+"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.Transcriptions = void 0;
+const VocalStackApi_1 = require("../VocalStackApi");
+class Transcriptions extends VocalStackApi_1.VocalStackApi {
+    getTranscription(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return this._rest().get(`/transcriptions/${id}`);
+        });
+    }
+    getAllTranscriptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._rest().get('/transcriptions');
+        });
+    }
+    addTranslation(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id, language }) {
+            return this._rest().post(`/transcription/${id}/language/${language}`);
+        });
+    }
+    removeTranslation(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._rest().delete(`/transcription/${req.id}/language/${req.language}`);
+        });
+    }
+    addTranslationAsync(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._ws().connect({
+                path: `/async/transcription/${req.id}/language/${req.language}`,
+            });
+        });
+    }
+}
+exports.Transcriptions = Transcriptions;

package/dist/apis/UrlTranscription.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { Timeline, Uuid } from '../generics.zod';
+import { VocalStackApi } from '../VocalStackApi';
+import { WebsocketConnection } from '../WebsocketApi';
+import { ApiResponse } from '../RestApi';
+import { Status } from './Transcriptions';
+declare const zUrlTranscriptionStartRequest: z.ZodObject<{
+    url: z.ZodString;
+    duration_s: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    max_duration_s: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    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"]>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    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;
+    max_duration_s?: number | undefined;
+    duration_s?: number | undefined;
+}, {
+    url: string;
+    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;
+    max_duration_s?: number | undefined;
+    duration_s?: number | undefined;
+}>;
+export type UrlTranscriptionStartRequest = z.infer<typeof zUrlTranscriptionStartRequest>;
+export type UrlTranscriptionStreamData = ArrayBufferLike;
+export type UrlTranscriptionResponse = {
+    status: Status;
+    data: UrlTranscriptionResponseData | null;
+    http_code?: number;
+};
+export type UrlTranscriptionResponseData = {
+    id: Uuid;
+    status: Status;
+    operation: 'transcription-prerecorded';
+    start: string;
+    end: string | null;
+    flags?: {
+        started: boolean;
+    } | null;
+    keywords?: string | null;
+    timeline?: Timeline;
+    paragraphs?: string[] | null;
+    summary?: string | null;
+    progress: number;
+};
+export type UrlTranscriptionStopRequest = {
+    id: string;
+};
+export type UrlTranscriptionConnection = WebsocketConnection<UrlTranscriptionResponse>;
+export type UrlTranscriptionRestResponse = ApiResponse<{
+    id: Uuid;
+    status: 'processing' | 'error';
+    http_code?: number;
+}>;
+export declare class UrlTranscription extends VocalStackApi {
+    connect(request: UrlTranscriptionStartRequest): Promise<UrlTranscriptionConnection>;
+    transcribe(request: UrlTranscriptionStartRequest): Promise<UrlTranscriptionRestResponse>;
+    private getQuery;
+}
+export {};

package/dist/apis/UrlTranscription.js

@@ -0,0 +1,53 @@
+"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.UrlTranscription = void 0;
+const zod_1 = require("zod");
+const generics_zod_1 = require("../generics.zod");
+const VocalStackApi_1 = require("../VocalStackApi");
+const zUrlTranscriptionStartRequest = zod_1.z.object({
+    url: zod_1.z.string(),
+    duration_s: generics_zod_1.zDuration.optional(),
+    max_duration_s: generics_zod_1.zDuration.optional(),
+    language: generics_zod_1.zLanguage.optional(),
+});
+class UrlTranscription extends VocalStackApi_1.VocalStackApi {
+    connect(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryString = this.getQuery(request);
+            return this._ws().connect({
+                path: `/async/transcribe/url?${queryString}`,
+                mustStart: true,
+                headers: {},
+            });
+        });
+    }
+    transcribe(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryString = this.getQuery(request);
+            return this._rest().post(`/async/transcribe/url?${queryString}`);
+        });
+    }
+    getQuery(request) {
+        const validation = this.withValidation(zUrlTranscriptionStartRequest, request);
+        if (validation.badResponse) {
+            throw new Error(validation.badResponse.error);
+        }
+        const queryString = this.buildQueryString({
+            language: request.language || 'auto',
+            url: encodeURIComponent(request.url),
+            duration_s: request.duration_s,
+            max_duration_s: request.max_duration_s,
+        });
+        return queryString;
+    }
+}
+exports.UrlTranscription = UrlTranscription;

package/dist/apis/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Transcriptions';
+export * from './LiveTranscription';
+export * from './UrlTranscription';
+export * from './Polyglot';
+export * from './Security';
+export * from './Billing';

package/dist/apis/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Transcriptions"), exports);
+__exportStar(require("./LiveTranscription"), exports);
+__exportStar(require("./UrlTranscription"), exports);
+__exportStar(require("./Polyglot"), exports);
+__exportStar(require("./Security"), exports);
+__exportStar(require("./Billing"), exports);

package/dist/esm/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;
+}