@sidevoice/engine 0.0.0 → 0.4.0

package/dist/sidevoice_engine.d.ts

@@ -0,0 +1,447 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/** What every promise of the engine rejects with: the engine's stable code and its parameters, and, for a call a
+ * remote provider refused, what the provider said (`detail`: its own code and message), to show as it is. */
+export interface EngineError extends Error { code: string; params: Record<string, number>; detail?: string; }
+/** Why a build does not run here: a stable code and its numbers (`needs`, `has`) when there are any. */
+export interface Reason { code: string; params: { needs?: number; has?: number }; }
+export interface Voice { id: string; name?: string; languages: string[]; gender?: "female" | "male"; }
+export interface ModelBuild {
+    id: string; backend: string; accelerator?: string; precision: string; downloadBytes: number; memoryMb: number;
+    available: boolean; reasons: Reason[]; installed: boolean;
+}
+/** The speeds a model takes, 1 being its normal pace. A model with no `speed` takes none. */
+export interface SpeedRange { min: number; max: number; }
+/** A model as a catalogue lists it, whichever: what every model has. */
+export interface ModelInfo {
+    id: string; capabilities: ("stt" | "tts" | "vad" | "end-of-turn")[]; languages: string[];
+    voices: Voice[]; speed?: SpeedRange;
+}
+/** A model of the local catalogue: its family, size, licence, builds ranked, what is installed and when it was
+ * last loaded. */
+export interface LocalModelInfo extends ModelInfo {
+    family: string; parametersM: number; license: string; installed: boolean;
+    /** When it was last loaded, in milliseconds since the epoch; absent when it is not installed or not loaded since. */
+    lastUsedAt?: number;
+    builds: ModelBuild[]; recommendedBuild?: string;
+}
+/** A model of a remote provider, as listed. */
+export interface RemoteModelInfo extends ModelInfo {}
+/** A model ready to use, from a catalogue's `load`: either hands out the same capabilities. */
+export type Model = LocalModel | RemoteModel;
+/** A place models come from: what the local catalogue and each provider's have in common (`id`, `name`, `status()`,
+ * `models(capability?)`, `refresh()`, `load(model)`). Each lists and loads its own types; nothing tells them apart but
+ * which catalogue was asked. */
+export type Catalog = LocalCatalog | RemoteCatalog;
+/** How a catalogue stands: why it is not current (absent when it is), whether its models are the last kept, and what
+ * the provider said when it last refused, for a developer to read. */
+export interface CatalogStatus { reason?: Reason; stale: boolean; detail?: string; }
+/** How far an install has got: files done of all, and the bytes of the file being downloaded. */
+export interface Progress { files: number; done: number; received: number; size?: number; }
+export interface Audio { samples: Float32Array; sampleRate: number; }
+/** How a voice activity stream decides what is speech; each left out takes its default (0.5, 500 ms, 250 ms). */
+export interface VadOptions { threshold?: number; minSilenceMs?: number; minSpeechMs?: number; }
+/** One window of a stream: where it ends (in samples), whether the stream is in speech, the model's probability. */
+export interface VadFrame { end: number; speech: boolean; probability?: number; }
+/** Speech confirmed at `at`, or speech that ran from `start` to just before `end`: positions in samples. */
+export type VadEvent = { type: "speech-start"; at: number } | { type: "speech-end"; start: number; end: number };
+export interface VadOutput { frames: VadFrame[]; events: VadEvent[]; }
+
+
+
+/**
+ * A model, local or remote, as an end-of-turn classifier.
+ */
+export class EndOfTurn {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The probability, from 0 to 1, that the turn in `audio` (mono samples at `sampleRate` Hz, from its start to now)
+     * is complete; the engine keeps the last `seconds` and resamples them.
+     */
+    probability(audio: Float32Array, sampleRate: number): Promise<number>;
+    /**
+     * How many seconds of the end of a turn the model hears: earlier audio does not count.
+     */
+    readonly seconds: number;
+}
+
+/**
+ * The local catalogue, for JavaScript.
+ */
+export class LocalCatalog {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The model `model`, loaded as `WebEngine.load` does with no build (installing it first and telling
+     * `onProgress`; `signal` aborts it).
+     */
+    load(model: string, onProgress: (progress: Progress) => void, signal?: AbortSignal | null): Promise<LocalModel>;
+    /**
+     * Its models, those of `capability` alone when given (`"stt"`, `"tts"`, `"vad"`, `"end-of-turn"`), each with its
+     * builds ranked, what is installed and when it was last loaded (`lastUsedAt`); rejects with `invalid-capability`
+     * for any other.
+     */
+    models(capability: "stt" | "tts" | "vad" | "end-of-turn"): Promise<LocalModelInfo[]>;
+    /**
+     * Nothing to read again: compiled in. Its status.
+     */
+    refresh(): Promise<CatalogStatus>;
+    /**
+     * How it stands: always current.
+     */
+    status(): Promise<CatalogStatus>;
+    /**
+     * Its id: `"local"`.
+     */
+    readonly id: string;
+    /**
+     * Absent: the app names the local catalogue.
+     */
+    readonly name: string | undefined;
+}
+
+/**
+ * A local model in memory, for JavaScript. It and the `Stt` and `Tts` it hands out each keep the model in memory:
+ * freeing them all (`free()`, or letting them be collected) unloads it.
+ */
+export class LocalModel {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The model as an end-of-turn classifier, if it is one.
+     */
+    asEndOfTurn(): EndOfTurn | undefined;
+    /**
+     * The model as speech to text, if it is one.
+     */
+    asStt(): Stt | undefined;
+    /**
+     * The model as text to speech, if it is one.
+     */
+    asTts(): Tts | undefined;
+    /**
+     * The model as a voice activity detector, if it is one.
+     */
+    asVad(): Vad | undefined;
+    /**
+     * What it can do: `"stt"`, `"tts"`, `"vad"`, `"end-of-turn"`.
+     */
+    capabilities(): ("stt" | "tts" | "vad" | "end-of-turn")[];
+    /**
+     * The id of the build that was loaded.
+     */
+    readonly build: string;
+    /**
+     * The model's id.
+     */
+    readonly id: string;
+}
+
+/**
+ * A remote provider's catalogue, for JavaScript.
+ */
+export class RemoteCatalog {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The model `model`, as listed: it calls the provider each time it is used. `onProgress` is never called (nothing
+     * is installed); `signal` aborts it.
+     */
+    load(model: string, onProgress: (progress: Progress) => void, signal?: AbortSignal | null): Promise<RemoteModel>;
+    /**
+     * Its models as listed, those of `capability` alone when given; rejects with `invalid-capability` for any other.
+     */
+    models(capability: "stt" | "tts" | "vad" | "end-of-turn"): Promise<RemoteModelInfo[]>;
+    /**
+     * Reads it again now, whatever its age: its status after.
+     */
+    refresh(): Promise<CatalogStatus>;
+    /**
+     * How it stands: `{ reason?, stale, detail? }`, listing the provider first if its listing is missing or old.
+     */
+    status(): Promise<CatalogStatus>;
+    /**
+     * Its id: the provider's.
+     */
+    readonly id: string;
+    /**
+     * The provider's name ("OpenAI").
+     */
+    readonly name: string | undefined;
+}
+
+/**
+ * A remote provider's model, for JavaScript: each call on what it hands out goes to the provider.
+ */
+export class RemoteModel {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The model as an end-of-turn classifier, if it is one.
+     */
+    asEndOfTurn(): EndOfTurn | undefined;
+    /**
+     * The model as speech to text, if it is one.
+     */
+    asStt(): Stt | undefined;
+    /**
+     * The model as text to speech, if it is one.
+     */
+    asTts(): Tts | undefined;
+    /**
+     * The model as a voice activity detector, if it is one.
+     */
+    asVad(): Vad | undefined;
+    /**
+     * What it can do: `"stt"`, `"tts"`, `"vad"`, `"end-of-turn"`.
+     */
+    capabilities(): ("stt" | "tts" | "vad" | "end-of-turn")[];
+    /**
+     * The provider's id of the model.
+     */
+    readonly id: string;
+    /**
+     * The provider's id.
+     */
+    readonly provider: string;
+}
+
+/**
+ * A model, local or remote, as speech to text.
+ */
+export class Stt {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * What is said in `audio` (mono samples at `sampleRate` Hz, one whole turn; the engine resamples it), in
+     * `language` (a BCP 47 tag), or in the one the model detects when left out.
+     */
+    transcribe(audio: Float32Array, sampleRate: number, language?: string | null): Promise<string>;
+}
+
+/**
+ * A model, local or remote, as text to speech.
+ */
+export class Tts {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * `text` spoken with `voice` (one of `voices()`), in `language` (a BCP 47 tag) for a model that speaks several,
+     * at `speed` (1 when left out): `{ samples, sampleRate }`, at the model's own rate.
+     */
+    speak(text: string, voice: string, language?: string | null, speed?: number | null): Promise<Audio>;
+    /**
+     * The voices it speaks with: `{ id, languages, gender? }`.
+     */
+    voices(): Promise<Voice[]>;
+}
+
+/**
+ * A model, local or remote, as a voice activity detector.
+ */
+export class Vad {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * A new stream, from sample 0 and with no speech, deciding with `options` (each left out takes its default).
+     * Rejects with `invalid-vad-options` for options out of their bounds or of the wrong type.
+     */
+    stream(options: VadOptions): Promise<VadStream>;
+}
+
+/**
+ * One stream of audio through a voice activity detector: feed it mono samples at `sampleRate` as they come, in pieces
+ * of any length. It keeps the model in memory until it is freed. Calls on it wait for one another.
+ */
+export class VadStream {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Takes the next `samples` and runs the model on every whole window it now has: `{ frames, events }`.
+     */
+    accept(samples: Float32Array): Promise<VadOutput>;
+    /**
+     * Ends the stream's audio: the speech in progress, if any, as its `speech-end` event (else `undefined`); the
+     * stream then starts over from sample 0.
+     */
+    finish(): Promise<VadEvent | undefined>;
+    /**
+     * Starts over from sample 0, forgetting any speech in progress.
+     */
+    reset(): Promise<void>;
+    /**
+     * The rate the stream takes, in Hz: the model's own. It is not resampled.
+     */
+    readonly sampleRate: number;
+    /**
+     * How many samples one window, one frame, holds.
+     */
+    readonly window: number;
+}
+
+/**
+ * The engine, for JavaScript.
+ */
+export class WebEngine {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The ids of the backends in this build.
+     */
+    backends(): string[];
+    /**
+     * The catalogue `id` (`"local"`, `"openai"`, `"elevenlabs"`); throws `catalog-not-found` for any other.
+     */
+    catalog(id: string): LocalCatalog | RemoteCatalog;
+    /**
+     * Every catalogue of this engine: the `LocalCatalog` first, then each provider's `RemoteCatalog`, by id. Both have
+     * `id`, `name`, `status()`, `models(capability?)`, `refresh()` and `load(model)`; each lists and loads its own
+     * types.
+     */
+    catalogs(): (LocalCatalog | RemoteCatalog)[];
+    /**
+     * Asks the host for its capabilities once, and builds the engine on the bundled catalogue. The host may also have
+     * `credential(provider)`, which returns (or resolves to) the key of a remote provider (`"openai"`, `"elevenlabs"`)
+     * or `null`: the engine asks it each time a provider is listed or a remote model called, and keeps no key.
+     * Rejects with `host-capabilities` when the host's `capabilities()` fails, `host-capabilities-<field>` when what it
+     * reports is malformed.
+     */
+    static create(host: any): Promise<WebEngine>;
+    /**
+     * Installs `build` of `model` (the recommended one when left out), telling `onProgress` as it goes; `signal`
+     * aborts it, and the promise rejects with `cancelled`, leaving nothing half downloaded.
+     */
+    install(model: string, build: string | null | undefined, onProgress: (progress: Progress) => void, signal?: AbortSignal | null): Promise<void>;
+    /**
+     * Loads `build` of `model` (an installed one that runs here, else the recommended one, when left out),
+     * installing it first if it is not, as [`WebEngine::install`] does. The model stays in memory while a
+     * `LocalModel` of its build lives, or an `Stt` or `Tts` one handed out: freeing them all (`free()`, or letting
+     * them be collected) unloads it.
+     */
+    load(model: string, build: string | null | undefined, onProgress: (progress: Progress) => void, signal?: AbortSignal | null): Promise<LocalModel>;
+    /**
+     * The local catalogue: its models are `LocalModelInfo`s (builds, install state) and it loads `LocalModel`s.
+     */
+    localCatalog(): LocalCatalog;
+    /**
+     * The remote provider `id`: its models are `RemoteModelInfo`s and it loads `RemoteModel`s; throws
+     * `catalog-not-found` for an id that is no provider.
+     */
+    remoteCatalog(id: string): RemoteCatalog;
+    /**
+     * Removes `build` of `model` (every build of it when left out), except files another build uses; rejects with
+     * `build-not-found`, or `model-in-use` while one of those builds is loaded; it waits for installs and loads in
+     * progress.
+     */
+    uninstall(model: string, build?: string | null): Promise<void>;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_endofturn_free: (a: number, b: number) => void;
+    readonly __wbg_localcatalog_free: (a: number, b: number) => void;
+    readonly __wbg_localmodel_free: (a: number, b: number) => void;
+    readonly __wbg_remotecatalog_free: (a: number, b: number) => void;
+    readonly __wbg_remotemodel_free: (a: number, b: number) => void;
+    readonly __wbg_stt_free: (a: number, b: number) => void;
+    readonly __wbg_tts_free: (a: number, b: number) => void;
+    readonly __wbg_vad_free: (a: number, b: number) => void;
+    readonly __wbg_vadstream_free: (a: number, b: number) => void;
+    readonly __wbg_webengine_free: (a: number, b: number) => void;
+    readonly endofturn_probability: (a: number, b: number, c: number, d: number) => any;
+    readonly endofturn_seconds: (a: number) => number;
+    readonly localcatalog_id: (a: number) => [number, number];
+    readonly localcatalog_load: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly localcatalog_models: (a: number, b: number, c: number) => any;
+    readonly localcatalog_name: (a: number) => [number, number];
+    readonly localcatalog_refresh: (a: number) => any;
+    readonly localcatalog_status: (a: number) => any;
+    readonly localmodel_asEndOfTurn: (a: number) => number;
+    readonly localmodel_asStt: (a: number) => number;
+    readonly localmodel_asTts: (a: number) => number;
+    readonly localmodel_asVad: (a: number) => number;
+    readonly localmodel_build: (a: number) => [number, number];
+    readonly localmodel_capabilities: (a: number) => [number, number];
+    readonly localmodel_id: (a: number) => [number, number];
+    readonly remotecatalog_id: (a: number) => [number, number];
+    readonly remotecatalog_load: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly remotecatalog_models: (a: number, b: number, c: number) => any;
+    readonly remotecatalog_name: (a: number) => [number, number];
+    readonly remotecatalog_refresh: (a: number) => any;
+    readonly remotecatalog_status: (a: number) => any;
+    readonly remotemodel_asEndOfTurn: (a: number) => number;
+    readonly remotemodel_asStt: (a: number) => number;
+    readonly remotemodel_asTts: (a: number) => number;
+    readonly remotemodel_asVad: (a: number) => number;
+    readonly remotemodel_capabilities: (a: number) => [number, number];
+    readonly remotemodel_id: (a: number) => [number, number];
+    readonly remotemodel_provider: (a: number) => [number, number];
+    readonly stt_transcribe: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+    readonly tts_speak: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+    readonly tts_voices: (a: number) => any;
+    readonly vad_stream: (a: number, b: number) => any;
+    readonly vadstream_accept: (a: number, b: number, c: number) => any;
+    readonly vadstream_finish: (a: number) => any;
+    readonly vadstream_reset: (a: number) => any;
+    readonly vadstream_sampleRate: (a: number) => number;
+    readonly vadstream_window: (a: number) => number;
+    readonly webengine_backends: (a: number) => [number, number];
+    readonly webengine_catalog: (a: number, b: number, c: number) => [number, number, number];
+    readonly webengine_catalogs: (a: number) => any;
+    readonly webengine_create: (a: any) => any;
+    readonly webengine_install: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly webengine_load: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly webengine_localCatalog: (a: number) => number;
+    readonly webengine_remoteCatalog: (a: number, b: number, c: number) => [number, number, number];
+    readonly webengine_uninstall: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly wasm_bindgen_63a46d96b29ae508___convert__closures_____invoke___alloc_508e33bd5656020b___string__String__js_sys_9a9f93f03cc98e8d___Promise__true_: (a: number, b: number, c: number, d: number) => any;
+    readonly wasm_bindgen_63a46d96b29ae508___convert__closures_____invoke___js_sys_9a9f93f03cc98e8d___Function_fn_wasm_bindgen_63a46d96b29ae508___JsValue_____wasm_bindgen_63a46d96b29ae508___sys__Undefined___js_sys_9a9f93f03cc98e8d___Function_fn_wasm_bindgen_63a46d96b29ae508___JsValue_____wasm_bindgen_63a46d96b29ae508___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen_63a46d96b29ae508___convert__closures_____invoke___wasm_bindgen_63a46d96b29ae508___JsValue__core_ed718c3d60ebd546___result__Result_____wasm_bindgen_63a46d96b29ae508___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_63a46d96b29ae508___convert__closures_____invoke_______true_: (a: number, b: number) => void;
+    readonly __wbindgen_malloc_command_export: (a: number, b: number) => number;
+    readonly __wbindgen_realloc_command_export: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store_command_export: (a: number) => void;
+    readonly __externref_table_alloc_command_export: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_destroy_closure_command_export: (a: number, b: number) => void;
+    readonly __wbindgen_free_command_export: (a: number, b: number, c: number) => void;
+    readonly __externref_drop_slice_command_export: (a: number, b: number) => void;
+    readonly __externref_table_dealloc_command_export: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;