@vocalstack/player 0.0.0-stage → 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VocalStack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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

@@ -1,3 +1,37 @@
-# Temporary Holding Version
+# @vocalstack/player
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A React video and transcript player for [VocalStack](https://vocalstack.com) transcriptions. It shows subtitles, a synced transcript, and spoken translations read in the speakers' own (cloned) or stock voices. It can also remove the background sound. It talks only to the public VocalStack API.
+
+```bash
+npm install @vocalstack/player
+```
+
+```tsx
+import { VocalStackPlayer } from '@vocalstack/player';
+import '@vocalstack/player/style.css';
+
+export function Video() {
+  return <VocalStackPlayer id="r4m4srrrhi24" mode="video" />;
+}
+```
+
+`id` is the share code from a VocalStack share link (`vocalstack.com/v/<code>`). Shared transcriptions need no key.
+
+## Props
+
+| Prop | Default | |
+|---|---|---|
+| `id` | required | A share code. Or, with `token`, a transcription id. |
+| `token` | none | A browser token (or a function returning one) for a private transcription. Never pass an API key to a browser. |
+| `mode` | `'video'` | `'video'` for the full player, `'transcript'` for the reading view with a player. |
+| `layout` | `'embed'` | `'embed'` sizes to its container (16:9 for video); `'page'` fills the page. |
+| `initial` | none | `{ lang, cc, translateAudio, clonedVoices, removeBackground, labels, words, startAt }` |
+| `endCard` | on | At the end of a video, offers to transcribe another link in the visitor's own VocalStack account. Pass `false` to turn it off. |
+| `baseUrl` | `https://api.vocalstack.com` | |
+| `onSource`, `onProgress`, `onError` | none | Callbacks for the loaded transcription, the transcription progress (0-100, `null` when done), and errors. |
+
+Theme it by overriding the CSS variables on `.vsp`, for example `--vsp-radius`, `--brand` and `--vs-font-sans`.
+
+## License
+
+MIT

package/dist/core/audio.d.ts

@@ -0,0 +1,39 @@
+export declare function setErrorReporter(fn: ((e: Error) => void) | null): void;
+export declare function reportError(e: Error): void;
+export declare function liveAudioSupported(): boolean;
+export declare class LivePlayer {
+    private ctx;
+    private decoder;
+    private demux;
+    private nextTime;
+    private gain;
+    private headerSeen;
+    private ts;
+    volume: number;
+    start(): Promise<void>;
+    setVolume(v: number): void;
+    feed(bytes: ArrayBuffer): void;
+    private play;
+    stop(): Promise<void>;
+}
+export declare function deliveryFormat(): 'ogg' | 'caf';
+export interface MediaCred {
+    accessToken?: string | null;
+    listenerToken?: string | null;
+    shareCode?: string | null;
+    media?: string | null;
+}
+export declare function credParams(cred?: MediaCred): string;
+export declare function audioClipUrl(apiOrigin: string, recordingId: string, startS: number, endS: number, cred?: MediaCred, clean?: boolean): string;
+export declare function explainAudioError(url: string): Promise<{
+    message: string;
+    permanent: boolean;
+} | null>;
+export declare function audioSealed(url: string): Promise<boolean>;
+export declare function deliveryAudioUrl(apiOrigin: string, recordingId: string, cred?: MediaCred): string;
+export declare function backgroundAudioUrl(apiOrigin: string, recordingId: string, cred?: MediaCred, kind?: 'background' | 'speech'): string;
+export declare function audioDownloadUrl(apiOrigin: string, recordingId: string, kind: 'source' | 'delivery' | 'video', cred?: MediaCred): string;
+export declare function voiceTrackUrl(apiOrigin: string, recordingId: string, lang: string, voiceKey: string, cred?: MediaCred): string;
+export declare function voiceTrackDownloadUrl(apiOrigin: string, recordingId: string, lang: string, voiceKey: string, cred?: MediaCred): string;
+export declare function mediaErrorText(e: MediaError | null, report?: boolean): string;
+export declare function reportMediaError(e: MediaError | null): void;

package/dist/core/background.d.ts

@@ -0,0 +1,54 @@
+export type BedState = 'off' | 'making' | 'ready' | 'unavailable';
+export declare const BED_DRIFT_S = 0.3;
+export interface BedMedia {
+    currentTime: number;
+    paused: boolean;
+    muted: boolean;
+    play: () => Promise<void> | void;
+    pause: () => void;
+}
+export declare function followBed(a: BedMedia, want: {
+    t: number;
+    playing: boolean;
+    muted: boolean;
+}): void;
+export declare const REMOVE_BG_LABEL = "Remove background sound";
+export declare const REMOVE_BG_NOTE = "Takes out everything that isn't speech: music, ambience and noise.";
+export declare function bedNote(on: boolean, state: BedState, what?: 'transcription' | 'video', untilS?: number): string;
+export interface TrackPlan {
+    bed: boolean;
+    speech: boolean;
+}
+export declare function trackPlan(removeBg: boolean, voiceOn: boolean): TrackPlan;
+export declare function removeBgOf(stored: boolean | null, oldKeep: boolean | null): boolean;
+export declare function removeBgFromQuery(q: URLSearchParams): boolean;
+export declare function withRemoveBg(u: URL, removeBg: boolean): void;
+export declare function bedRetryS(status: number, body: unknown): number | null;
+export interface SepPart {
+    startS: number;
+    endS: number;
+    url: string;
+}
+export declare const SEAM_S = 0.05;
+export declare function partsOf(body: unknown): {
+    untilS: number;
+    parts: SepPart[];
+};
+export declare function partAt(parts: SepPart[], t: number): number;
+export declare function slotsFor(parts: SepPart[], i: number, held: [number, number], cur: 0 | 1): {
+    play: 0 | 1;
+    load: Array<[0 | 1, number]>;
+};
+export interface Separated {
+    state: BedState;
+    on: boolean;
+    untilS: number;
+}
+type Want = {
+    t: number;
+    playing: boolean;
+    muted: boolean;
+};
+export declare function useSeparatedTrack(url: string | null, want: Want): Separated;
+export declare function useBackgroundBed(url: string | null, want: Want): BedState;
+export {};

package/dist/core/clipPrefetch.d.ts

@@ -0,0 +1,38 @@
+export type Fetcher = (src: string, signal: AbortSignal) => Promise<{
+    ok: boolean;
+    status: number;
+    blob: () => Promise<Blob>;
+}>;
+export interface PrefetchOptions {
+    fetcher?: Fetcher;
+    concurrency?: number;
+    keep?: number;
+    retryMs?: number;
+    now?: () => number;
+    toUrl?: (b: Blob) => string;
+    revoke?: (url: string) => void;
+}
+export declare class ClipPrefetch {
+    private entries;
+    private wanted;
+    private used;
+    private readonly fetcher;
+    private readonly concurrency;
+    private readonly keep;
+    private readonly retryMs;
+    private readonly now;
+    private readonly toUrl;
+    private readonly revoke;
+    onReady: (src: string) => void;
+    constructor(o?: PrefetchOptions);
+    want(srcs: string[]): void;
+    urlFor(src: string): string;
+    ready(src: string): boolean;
+    loading(): number;
+    forget(src: string): void;
+    clear(): void;
+    private evict;
+    private usedRank;
+    private pump;
+    private load;
+}

package/dist/core/clipQueue.d.ts

@@ -0,0 +1,130 @@
+import { ClipPrefetch } from './clipPrefetch';
+export declare const mediaKind: {
+    video: boolean;
+};
+export declare function newMediaElement(url?: string): HTMLMediaElement;
+export interface VoiceClip {
+    sentenceId: number;
+    lang: string;
+    src: string;
+    durationS: number;
+    generation?: number;
+    part: number;
+    parts: number;
+    voice?: string | null;
+    cloned?: boolean;
+}
+export declare class VoiceNotStarted extends Error {
+    constructor();
+}
+export declare class ClipQueue {
+    private el;
+    private clips;
+    private order;
+    current: number | null;
+    private currentPart;
+    private partBase;
+    private within;
+    playing: boolean;
+    muted: boolean;
+    rate: number;
+    volume: number;
+    finite: boolean;
+    onSentence: (id: number | null) => void;
+    onWaiting: (id: number | null) => void;
+    onStarting: (since: number | null) => void;
+    speakable: (sentenceId: number) => boolean;
+    coming: (sentenceId: number) => boolean;
+    gapBefore: (prev: number | null, next: number) => number;
+    flow: boolean;
+    silentSpan: (sentenceId: number) => {
+        fromS: number;
+        ms: number;
+    } | null;
+    private lastDone;
+    private rested;
+    private rest;
+    private sequence;
+    private seqAt;
+    setSequence(ids: number[]): void;
+    private rank;
+    private expected;
+    static WAIT_MS: number;
+    static START_WAIT_MS: number;
+    static COMING_MS: number;
+    static SKEW_LINES: number;
+    private spoken;
+    private lastRead;
+    private started;
+    private awaiting;
+    private waitTimer;
+    onError: (e: unknown) => void;
+    private floor;
+    private loading;
+    readAhead: number;
+    readAheadS: number;
+    readonly prefetch: ClipPrefetch;
+    private warmed;
+    private static readonly RETRIES;
+    private static readonly RETRY_MS;
+    private static readonly STARTING_MS;
+    private startingSince;
+    private retries;
+    private retryTimer;
+    add(clip: VoiceClip): void;
+    private piecesOf;
+    private due;
+    private follow;
+    private restAfter;
+    joinSilently(id: number): void;
+    private silentLine;
+    private runRest;
+    private holdRest;
+    private clearRest;
+    resting(): {
+        sentenceId: number;
+        s: number;
+        silent: boolean;
+    } | null;
+    private finishLine;
+    private earliestHeld;
+    private floorOrBefore;
+    private waitFor;
+    private stopWaiting;
+    has(sentenceId: number): boolean;
+    get size(): number;
+    latest(): VoiceClip | null;
+    clipAt(sentenceId: number): VoiceClip | null;
+    private from;
+    private edge;
+    play(sentenceId: number | null): void;
+    pause(): void;
+    resume(sentenceId: number | null): boolean;
+    private swap;
+    readingAt(): number | null;
+    arm(sentenceId: number | null): void;
+    seekWithin(t: number): void;
+    seek(sentenceId: number | null): void;
+    setMuted(m: boolean): void;
+    setVolume(v: number): void;
+    setRate(r: number): void;
+    private start;
+    private startPartAt;
+    startWithin(sentenceId: number, frac: number): void;
+    private startPart;
+    upcoming(from: number, withFrom?: boolean): VoiceClip[];
+    private warm;
+    private srcOf;
+    private failed;
+    private classify;
+    private drop;
+    position(): {
+        sentenceId: number;
+        t: number;
+        dur: number;
+    } | null;
+    private element;
+    resync(): void;
+    clear(): void;
+    stop(): void;
+}

package/dist/core/format.d.ts

@@ -0,0 +1,17 @@
+export declare function clock(s: number): string;
+export declare function durationLabel(s?: number | null): string;
+export declare function monDay(iso?: string | null): {
+    mon: string;
+    day: string;
+};
+export declare function timeOfDay(iso?: string | null): string;
+export declare function recordingWhen(iso?: string | null): string;
+export declare function dayGroup(iso?: string | null): string;
+export declare function whenLabel(iso?: string | null): string;
+export declare function ago(iso?: string | null): string;
+export declare function dwell(s: number): string;
+export declare function highlightParts(text: string, query: string): {
+    t: string;
+    hit: boolean;
+}[];
+export declare function pluralize(n: number, one: string, many?: string): string;

package/dist/core/mediaKeys.d.ts

@@ -0,0 +1,14 @@
+export type MediaKey = 'play' | 'pause' | 'stop' | 'nexttrack' | 'previoustrack';
+export interface MediaKeyTarget {
+    playing: boolean;
+    toggle: () => void;
+    next?: () => void;
+    prev?: () => void;
+}
+export declare const MEDIA_KEYS: MediaKey[];
+export declare function onMediaKey(key: MediaKey, t: MediaKeyTarget): void;
+export interface MediaSessionLike {
+    setActionHandler: (action: MediaKey, handler: (() => void) | null) => void;
+}
+export declare function bindMediaKeys(ms: MediaSessionLike, get: () => MediaKeyTarget | null): () => void;
+export declare function useMediaKeys(target: MediaKeyTarget | null, title?: string | null): void;

package/dist/core/noAudio.d.ts

@@ -0,0 +1,18 @@
+export interface AudioFacts {
+    state?: string | null;
+    mediaDurationS?: number | null;
+    ingest?: {
+        state?: string | null;
+        error?: string | null;
+        startedAt?: string | null;
+    } | null;
+}
+export type NoAudio = {
+    none: false;
+} | {
+    none: true;
+    message: string;
+};
+export declare function recordingAudio(rec: AudioFacts | null | undefined, lines: number): NoAudio;
+export declare function noAudioMessage(reason?: string | null): string;
+export declare function isNotCaptured(message?: string | null): boolean;

package/dist/core/playPosition.d.ts

@@ -0,0 +1,18 @@
+export interface PlaySlot {
+    sentenceId?: number | null;
+    start: number;
+}
+export interface PlayPos {
+    t: number;
+    playing: boolean;
+    sentenceId: number | null;
+    offset: number;
+    ended: boolean;
+}
+export interface PlayPlace {
+    t: number;
+    playing: boolean;
+    index: number;
+}
+export declare function snapPosition(rows: readonly PlaySlot[], t: number, playing: boolean, dur: number): PlayPos;
+export declare function placePosition(pos: PlayPos, rows: readonly PlaySlot[], dur: number): PlayPlace;

package/dist/core/qr.d.ts

@@ -0,0 +1,2 @@
+export declare function qrMatrix(text: string): boolean[][];
+export declare function qrSvgUrl(text: string): string;

package/dist/core/readalong.d.ts

@@ -0,0 +1,17 @@
+export declare const SUB_LEAD_S = 0.3;
+export declare const SUB_LINGER_S = 1.5;
+export interface Timed {
+    start: number;
+    end?: number;
+    words: {
+        start: number;
+        end: number;
+    }[];
+}
+export declare function lineSpeechEnd(r: Timed, next: Timed | undefined, fallback: number): number;
+export declare function subtitleShown(rows: Timed[], i: number, t: number): boolean;
+export declare function spreadWords(tokens: string[], from: number, to: number): {
+    text: string;
+    start: number;
+    end: number;
+}[];

package/dist/core/transcript.d.ts

@@ -0,0 +1,126 @@
+import type { Correction, TranscriptSnapshot } from '@vocalstack/js-sdk';
+export declare function fixedSlots(corrections: Correction[]): Set<string>;
+export interface Word {
+    text: string;
+    prob?: number | null;
+    start: number;
+    end: number;
+    alts?: {
+        text: string;
+        prob: number;
+    }[];
+    script?: boolean;
+    recognized?: string;
+    seq: number;
+    idx: number;
+}
+export interface Row {
+    id: string;
+    sentenceId?: number;
+    seqs: number[];
+    speaker: number;
+    start: number;
+    end?: number;
+    wallStart: number;
+    text: string;
+    words: Word[];
+    status: 'open' | 'closed';
+    settled: boolean;
+    corrected: boolean;
+    catchup: boolean;
+    suppressed: boolean;
+    unclear?: boolean;
+    confidence?: number;
+    latencyS?: number;
+    language?: string;
+    translations: Record<string, string>;
+    provisional: boolean;
+    translationLatencyS?: Record<string, number>;
+}
+export interface Segment {
+    seq: number;
+    speaker: number;
+    start: number;
+    end: number;
+    text: string;
+    words: Word[];
+    catchup: boolean;
+    corrected: boolean;
+    settled: boolean;
+    suppressed: boolean;
+    unclear?: boolean;
+    confidence?: number;
+    latencyS?: number;
+    language?: string;
+    translations: Record<string, string>;
+    scriptPos?: number;
+    scriptFrom?: number;
+}
+export interface Model {
+    segments: Map<number, Segment>;
+    sentences: Map<number, Omit<Row, 'words' | 'text' | 'seqs'> & {
+        text: string;
+        seqs: number[];
+    }>;
+    speakers: Record<number, string>;
+    speakerSpeechS: Record<number, number>;
+    speakerSex: Record<number, 'male' | 'female'>;
+    speakerIds: Record<number, {
+        name: string;
+        voiceId?: string;
+        color?: string;
+        confidence?: number;
+        tone?: boolean;
+    }>;
+    labels?: 'auto' | 'on' | 'off';
+    lastSeq: number;
+    state: string;
+    spans: {
+        wallStart: number;
+        wallEnd?: number | null;
+        mediaStart: number;
+        mediaEnd?: number | null;
+    }[];
+    held?: {
+        fromMediaS: number;
+        language?: string;
+    } | null;
+    numbers?: Map<number, number>;
+}
+export declare function empty(): Model;
+export declare function mediaToWall(m: Model, media: number): number;
+export declare function fromSnapshot(snap: TranscriptSnapshot, base?: Model): Model;
+export declare function scriptPosAt(m: Model, at?: number): number | undefined;
+export declare function scriptSpan(m: Model, seqs: number[]): [number, number] | null;
+export declare function applyFrame(m: Model, f: any): Model;
+export declare function rows(m: Model): Row[];
+export declare function heldLine(m: Model): string | null;
+export declare const CONF_MID = 0.85;
+export declare const CONF_LOW = 0.75;
+export declare function confClass(p?: number | null): '' | 'mid' | 'low';
+export declare function lowWords(r: Row, threshold?: number): Word[];
+export declare const LANES: readonly ["a", "b", "c", "d", "e", "f", "g", "h"];
+export type Lane = (typeof LANES)[number];
+export declare function lane(speaker: number): Lane;
+export declare function speakerNumbers(m: Model): Map<number, number>;
+export declare function speakerNumber(m: Model, speaker: number): number;
+export declare function speakerName(m: Model, speaker: number): string | undefined;
+export declare function speakerLabel(m: Model, speaker: number): string;
+export declare function speakerInitial(m: Model, speaker: number): string;
+export declare function speakerColor(voiceColor?: string | null): {
+    fg: string;
+    soft: string;
+} | undefined;
+export declare function speakerLook(m: Model, speaker: number): {
+    fg?: string;
+    soft?: string;
+    lane: Lane;
+    hasVoice: boolean;
+};
+export declare function latestLatency(m: Model): number | undefined;
+export declare function peakLatency(m: Model): number;
+export declare function showLabels(m: Model, rows: {
+    speaker: number;
+}[], fallback?: {
+    speakerLabels?: 'auto' | 'on' | 'off' | null;
+} | null, own?: boolean): boolean;

package/dist/core/voiceFollow.d.ts

@@ -0,0 +1,44 @@
+export interface FollowLine {
+    sid: number;
+    start: number;
+    end: number;
+}
+export interface FollowClip {
+    src: string;
+    part: number;
+    parts: number;
+    durationS?: number | null;
+}
+export type FollowTarget = {
+    kind: 'play';
+    sid: number;
+    src: string;
+    offset: number;
+} | {
+    kind: 'missing';
+    sid: number;
+} | {
+    kind: 'done';
+    sid: number;
+} | {
+    kind: 'none';
+};
+export declare const FOLLOW_DRIFT_S = 0.5;
+export declare const FOLLOW_AHEAD = 3;
+export declare function lineAt(lines: readonly FollowLine[], t: number): number;
+export declare function followTarget(lines: readonly FollowLine[], clips: ReadonlyMap<number, readonly FollowClip[]>, t: number): FollowTarget;
+export declare function upcomingSrcs(lines: readonly FollowLine[], clips: ReadonlyMap<number, readonly FollowClip[]>, t: number, n?: number): string[];
+export interface FollowState {
+    missing: number | null;
+    sid: number | null;
+}
+export declare function useVoiceFollow(o: {
+    on: boolean;
+    lines: readonly FollowLine[];
+    clips: readonly (FollowClip & {
+        sentenceId: number;
+    })[];
+    t: number;
+    playing: boolean;
+    muted: boolean;
+}): FollowState;

package/dist/core/voiceRetry.d.ts

@@ -0,0 +1,2 @@
+export declare const STARTING_DEFAULT_MS = 3000;
+export declare function startingRetryMs(status: number, retryAfter: string | null, body: unknown): number | null;

package/dist/core/voiceplayer.d.ts

@@ -0,0 +1,31 @@
+import { type MediaCred } from './audio';
+import type { VoiceClip } from './clipQueue';
+export { ClipQueue, VoiceNotStarted, mediaKind, newMediaElement, type VoiceClip } from './clipQueue';
+export declare function clipOf(f: any, apiOrigin: string, listenerToken?: string | null): VoiceClip | null;
+export interface VoiceTrackRow {
+    lang: string;
+    voiceKey: string;
+    state: string;
+    durationS?: number | null;
+    error?: string | null;
+    clips: number[];
+    voice?: string | null;
+    wordTimes?: Record<string, [number, number][]>;
+    clipRev?: Record<string, string>;
+    clipDur?: Record<string, number>;
+    clipParts?: Record<string, number>;
+}
+export declare function rowForVoice(rows: VoiceTrackRow[], voiceId: string | null): VoiceTrackRow | null;
+export declare function archiveClips(row: VoiceTrackRow | null | undefined, recordingId: string, apiOrigin: string, cred?: MediaCred, sentenceIds?: number[]): VoiceClip[];
+export interface ReadToken {
+    t: string;
+    sp: string;
+}
+export declare function readTokens(text: string): ReadToken[];
+export interface ReadPos {
+    t: number;
+    dur: number;
+    words?: [number, number][] | null;
+}
+export declare function readCursor(tokens: ReadToken[], pos: ReadPos): number | null;
+export declare function tokenAt(tokens: ReadToken[], pos: number, dur: number): number;

package/dist/core/youtube.d.ts

@@ -0,0 +1,9 @@
+export declare const ytIdOf: (u: string | null | undefined) => string | null;
+export declare const YOUTUBE_LINK: RegExp;
+export declare const isLiveRefusal: (url: string | null | undefined, error: string | null | undefined) => boolean;
+export declare const previewEmbedUrl: (id: string) => string;
+export declare const ytThumbUrl: (id: string) => string;
+export declare const YT_D = "M2.25 12c0-2.6.2-4.3.5-5.2a2.3 2.3 0 0 1 1.6-1.6C5.8 4.8 12 4.8 12 4.8s6.2 0 7.65.4a2.3 2.3 0 0 1 1.6 1.6c.3.9.5 2.6.5 5.2s-.2 4.3-.5 5.2a2.3 2.3 0 0 1-1.6 1.6c-1.45.4-7.65.4-7.65.4s-6.2 0-7.65-.4a2.3 2.3 0 0 1-1.6-1.6c-.3-.9-.5-2.6-.5-5.2ZM10 9.25v5.5L14.75 12 10 9.25Z";
+export declare function youtubeTitle(id: string, signal?: AbortSignal): Promise<string | null>;
+export declare function youtubeChannel(id: string, signal?: AbortSignal): Promise<string | null>;
+export declare const liveEmbedUrl: (id: string) => string;

package/dist/data/connect.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_APP = "https://app.vocalstack.com";
+export interface Started {
+    transcriptionId: string;
+    recordingId: string;
+    token: string;
+    expiresAt: string | null;
+}
+export type PopupStatus = 'signing-in' | 'consent' | 'checking' | 'starting';
+export declare function openPopup(appUrl: string | undefined, ask: {
+    url?: string;
+    transcription?: string;
+}, onStatus?: (s: PopupStatus) => void): Promise<Started | null>;
+export declare function startFromEmbed(appUrl: string | undefined, url: string, onStatus?: (s: PopupStatus) => void): Promise<Started | null>;
+export declare function refreshToken(appUrl: string | undefined, transcriptionId: string): Promise<Started | null>;