@mediapipe/tasks-retrieval 1.1.0-rc.20260929

package/retrieval.d.ts

@@ -0,0 +1,706 @@
+/// <reference types="@webgpu/types" />
+
+/** Activation data type for model execution. */
+export declare type ActivationDataType = "FLOAT32" | "FLOAT16" | "INT16" | "INT8";
+
+/** An audio part in a multimodal content block. */
+export declare interface AudioPart {
+    audioData: Float32Array;
+}
+
+/**
+ * Copyright 2026 The MediaPipe Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** Chunking mode for document chunking. */
+export declare type ChunkingMode = "CHARACTER" | "WORD";
+
+/** A single multimodal content part. */
+export declare type ContentPart = TextPart | ImagePart | AudioPart;
+
+/**
+ * A default text chunking implementation using native C++ Wasm methods.
+ */
+export declare class DefaultTextChunker implements TextChunker {
+    /**
+     * Initializes the Wasm runtime and creates a new DefaultTextChunker instance.
+     * @export
+     */
+    static create(wasmFileset: WasmFileset, chunkSize?: number, chunkOverlap?: number, mode?: ChunkingMode): Promise<DefaultTextChunker>;
+    /**
+     * Creates a DefaultTextChunker from an already initialized Wasm module.
+     * @export
+     */
+    static createFromModule(wasmModule: WasmModule, chunkSize?: number, chunkOverlap?: number, mode?: ChunkingMode): DefaultTextChunker;
+    private constructor();
+    chunk(text: string): string[];
+}
+
+/**
+ * Copyright 2022 The MediaPipe Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * List of embeddings with an optional timestamp.
+ *
+ * One and only one of the two 'floatEmbedding' and 'quantizedEmbedding' will
+ * contain data, based on whether or not the embedder was configured to perform
+ * scalar quantization.
+ */
+export declare interface Embedding {
+    /**
+     *  Floating-point embedding. Empty if the embedder was configured to perform
+     * scalar-quantization.
+     */
+    floatEmbedding?: number[];
+    /**
+     * Scalar-quantized embedding. Empty if the embedder was not configured to
+     * perform scalar quantization.
+     */
+    quantizedEmbedding?: Uint8Array;
+    /**
+     * The index of the classifier head these categories refer to. This is
+     * useful for multi-head models.
+     */
+    headIndex: number;
+    /**
+     * The name of the classifier head, which is the corresponding tensor
+     * metadata name.
+     */
+    headName: string;
+}
+
+/** Package-neutral interface for generating embeddings across modalities. */
+export declare interface EmbeddingProvider {
+    /**
+     * Generates a high-dimensional vector embedding for the given content parts.
+     * Returns null if the content parts are unsupported by this provider.
+     */
+    embedContent(content: readonly ContentPart[]): Promise<Float32Array | number[] | null> | Float32Array | number[] | null;
+}
+
+/**
+ * A listener that receives the current MediaPipe packet timestamp. This is
+ * invoked even for empty packet.
+ */
+declare type EmptyPacketListener = (timestamp: number) => void;
+
+/** A listener that will be invoked with an absl::StatusCode and message. */
+declare type ErrorListener = (code: number, message: string) => void;
+
+/**
+ * Resolves the files required for the MediaPipe Task APIs.
+ *
+ * This class verifies whether SIMD is supported in the current environment and
+ * loads the SIMD files only if support is detected. The returned filesets
+ * require that the Wasm files are published without renaming. If this is not
+ * possible, you can invoke the MediaPipe Tasks APIs using a manually created
+ * `WasmFileset`.
+ */
+export declare class FilesetResolver {
+    /**
+     * Returns whether SIMD is supported in the current environment.
+     *
+     * If your environment requires custom locations for the MediaPipe Wasm files,
+     * you can use `isSimdSupported()` to decide whether to load the SIMD-based
+     * assets. Note that for ES6 Modules, SIMD is assumed to be always supported.
+     *
+     * @param useModule Whether to use ES6 Modules for the Wasm files.
+     * @export
+     * @return Whether SIMD support was detected in the current environment.
+     */
+    static isSimdSupported(useModule?: boolean): Promise<boolean>;
+    /**
+     * Creates a fileset for the MediaPipe Audio tasks.
+     *
+     * @export
+     * @param basePath An optional base path to specify the directory the Wasm
+     *    files should be loaded from. If not specified, the Wasm files are
+     *    loaded from the host's root directory.
+     * @param useModule Whether to use ES6 Modules for the Wasm files.
+     * @return A `WasmFileset` that can be used to initialize MediaPipe Audio
+     *    tasks.
+     */
+    static forAudioTasks(basePath?: string, useModule?: boolean): Promise<WasmFileset>;
+    /**
+     * Creates a fileset for the MediaPipe GenAI tasks.
+     *
+     * @export
+     * @param basePath An optional base path to specify the directory the Wasm
+     *    files should be loaded from. If not specified, the Wasm files are
+     *    loaded from the host's root directory.
+     * @param useModule Whether to use ES6 Modules for the Wasm files.
+     * @return A `WasmFileset` that can be used to initialize MediaPipe GenAI
+     *    tasks.
+     */
+    static forGenAiTasks(basePath?: string, useModule?: boolean): Promise<WasmFileset>;
+    /**
+     * Creates a fileset for the MediaPipe Retrieval tasks.
+     *
+     * @export
+     * @param basePath An optional base path to specify the directory the Wasm
+     *    files should be loaded from. If not specified, the Wasm files are
+     *    loaded from the host's root directory.
+     * @param useModule Whether to use ES6 Modules for the Wasm files.
+     * @return A `WasmFileset` that can be used to initialize MediaPipe Retrieval
+     *    tasks.
+     */
+    static forRetrievalTasks(basePath?: string, useModule?: boolean): Promise<WasmFileset>;
+    /**
+     * Creates a fileset for the MediaPipe Text tasks.
+     *
+     * @export
+     * @param basePath An optional base path to specify the directory the Wasm
+     *    files should be loaded from. If not specified, the Wasm files are
+     *    loaded from the host's root directory.
+     * @param useModule Whether to use ES6 Modules for the Wasm files.
+     * @return A `WasmFileset` that can be used to initialize MediaPipe Text
+     *    tasks.
+     */
+    static forTextTasks(basePath?: string, useModule?: boolean): Promise<WasmFileset>;
+    /**
+     * Creates a fileset for the MediaPipe LiteRT LM Text tasks.
+     *
+     * @export
+     * @param basePath An optional base path to specify the directory the Wasm
+     *    files should be loaded from. If not specified, the Wasm files are
+     *    loaded from the host's root directory.
+     * @param useModule Whether to use ES6 Modules for the Wasm files.
+     * @return A `WasmFileset` that can be used to initialize MediaPipe LiteRT LM
+     *    Text tasks.
+     */
+    static forLiteRtLmTextTasks(basePath?: string, useModule?: boolean): Promise<WasmFileset>;
+    /**
+     * Creates a fileset for the MediaPipe Vision tasks.
+     *
+     * @export
+     * @param basePath An optional base path to specify the directory the Wasm
+     *    files should be loaded from. If not specified, the Wasm files are
+     *    loaded from the host's root directory.
+     * @param useModule Whether to use ES6 Modules for the Wasm files.
+     * @return A `WasmFileset` that can be used to initialize MediaPipe Vision
+     *    tasks.
+     */
+    static forVisionTasks(basePath?: string, useModule?: boolean): Promise<WasmFileset>;
+}
+
+/** An image part in a multimodal content block. */
+export declare interface ImagePart {
+    imageBytes: Uint8Array;
+}
+
+/**
+ * Lightweight, in-memory implementation of VectorStore in TypeScript.
+ */
+export declare class MemoryVectorStore implements VectorStore {
+    upsert(records: readonly RetrievalRecord[]): void;
+    delete(ids: readonly string[]): void;
+    deleteByMetadata(metadataFilter: Record<string, string>): void;
+    search(queryEmbedding: Float32Array | readonly number[], topK: number, metadataFilter?: Record<string, string>): RetrievalRecord[];
+    get(ids: readonly string[]): RetrievalRecord[];
+    getAllRecordIds(): string[];
+    deleteAll(): void;
+    close(): void;
+}
+
+/**
+ * Copyright 2026 The MediaPipe Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** Options for configuring retrieval queries in SemanticRetriever. */
+export declare interface RetrievalOptions {
+    /** The maximum number of results to return. Defaults to 5. */
+    readonly limit?: number;
+    /** Key-value metadata filter to restrict matching records. */
+    readonly metadataFilter?: Record<string, string>;
+}
+
+/** Represents a single multi-modal record stored in the vector store. */
+export declare interface RetrievalRecord {
+    /** The unique identifier of the record. */
+    id: string;
+    /** The list of multi-modal parts that make up the record content. */
+    content: readonly ContentPart[];
+    /** The vector embeddings representing the record. */
+    embeddings: Float32Array;
+    /** The key-value metadata associated with the record. */
+    metadata: Record<string, string>;
+    /** The unique identifier of the parent document, if any. */
+    parentId?: string;
+    /** The identifiers of chunked child records, if any. */
+    childIds?: readonly string[];
+}
+
+/** Represents a retrieved document or multimedia chunk. */
+export declare interface RetrievalResult {
+    /** The unique identifier of the retrieved record. */
+    readonly id: string;
+    /** The list of multi-modal parts in the retrieved record. */
+    readonly content: readonly ContentPart[];
+    /** The metadata associated with the retrieved record. */
+    readonly metadata: Record<string, string>;
+    /** The similarity/relevance score of this retrieved result. */
+    readonly score: number;
+}
+
+/**
+ * SemanticRetriever coordinates document chunking, multimodal embedding,
+ * and high-dimensional vector search.
+ */
+export declare class SemanticRetriever {
+    /**
+     * Creates a SemanticRetriever from SemanticRetrieverComponents.
+     *
+     * @param components The SemanticRetriever components.
+     * @return A Promise resolving to the SemanticRetriever instance.
+     * @export
+     */
+    static createFromComponents(components: SemanticRetrieverComponents): Promise<SemanticRetriever>;
+    private constructor();
+    /**
+     * Inserts a text document into the retriever with automatic chunking.
+     * @export
+     */
+    insertDocument(id: string, text: string, metadata?: Record<string, string>): Promise<void>;
+    /**
+     * Inserts multimodal content parts under a single unique ID.
+     * @export
+     */
+    insertContent(id: string, parts: readonly ContentPart[], metadata?: Record<string, string>): Promise<void>;
+    /**
+     * Inserts an image into the retriever.
+     * @export
+     */
+    insertImage(id: string, imageBytes: Uint8Array, metadata?: Record<string, string>): Promise<void>;
+    /**
+     * Inserts pre-decoded PCM float audio samples into the retriever.
+     * @export
+     */
+    insertAudio(id: string, audioData: Float32Array, metadata?: Record<string, string>): Promise<void>;
+    /**
+     * Retrieves top-K nearest matching records based on a text or multimodal query.
+     * @export
+     */
+    retrieve(query: string | readonly ContentPart[], options?: RetrievalOptions): Promise<RetrievalResult[]>;
+    /**
+     * Deletes records and their chunks by ID(s), or records matching metadata filter.
+     * @export
+     */
+    delete(idsOrFilter: string | readonly string[] | Record<string, string>): Promise<void>;
+    /**
+     * Retrieves all unique top-level record IDs stored in the retriever.
+     * @export
+     */
+    getAllRecordIds(): Promise<string[]>;
+    /**
+     * Deletes all records from the retriever.
+     * @export
+     */
+    deleteAll(): Promise<void>;
+    /**
+     * Closes the retriever and frees resources.
+     * @export
+     */
+    close(): void;
+}
+
+/**
+ * Components used to initialize the SemanticRetriever.
+ */
+export declare class SemanticRetrieverComponents {
+    /**
+     * Adds an embedding provider to the SemanticRetriever.
+     *
+     * @param provider The embedding provider to add.
+     * @return The SemanticRetrieverComponents instance for chaining.
+     */
+    addProvider(provider: EmbeddingProvider): this;
+    /**
+     * Returns the registered embedding providers for the SemanticRetriever.
+     *
+     * @return A list of registered embedding providers.
+     */
+    providers(): readonly EmbeddingProvider[];
+    /**
+     * Sets the vector store for the SemanticRetriever.
+     *
+     * @param vectorStore The vector store to set.
+     * @return The SemanticRetrieverComponents instance for chaining.
+     */
+    setVectorStore(vectorStore: VectorStore): this;
+    /**
+     * Returns the vector store for the SemanticRetriever.
+     *
+     * @return The vector store for the SemanticRetriever.
+     */
+    vectorStore(): VectorStore | undefined;
+    /**
+     * Sets the text chunker for the SemanticRetriever.
+     *
+     * @param textChunker The text chunker to set.
+     * @return The SemanticRetrieverComponents instance for chaining.
+     */
+    setTextChunker(textChunker: TextChunker): this;
+    /**
+     * Returns the text chunker for the SemanticRetriever.
+     *
+     * @return The text chunker for the SemanticRetriever.
+     */
+    textChunker(): TextChunker | undefined;
+}
+
+/**
+ * A listener that receives the contents of a non-empty MediaPipe packet and
+ * its timestamp.
+ */
+declare type SimpleListener<T> = (data: T, timestamp: number) => void;
+
+/**
+ * Interface for chunking long text into smaller segments.
+ */
+export declare interface TextChunker {
+    /** Chunks the input text into a list of strings. */
+    chunk(text: string): string[] | Promise<string[]>;
+}
+
+/**
+ * Copyright 2026 The MediaPipe Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** A text part in a multimodal content block. */
+export declare interface TextPart {
+    text: string;
+}
+
+/**
+ * UniversalEmbedder performs multimodal embedding extraction directly
+ * using LiteRT LM.
+ */
+export declare class UniversalEmbedder {
+    /**
+     * Initializes the Wasm runtime and creates a new UniversalEmbedder instance.
+     * @export
+     */
+    static createFromOptions(wasmFileset: WasmFileset, options: UniversalEmbedderOptions): Promise<UniversalEmbedder>;
+    /**
+     * Creates a WebGPU device for GPU-accelerated universal multimodal embedding.
+     * @export
+     */
+    static createWebGpuDevice(): Promise<GPUDevice>;
+    /**
+     * Initializes the Wasm runtime and creates a UniversalEmbedder from a model buffer.
+     * @export
+     */
+    static createFromModelBuffer(wasmFileset: WasmFileset, modelAssetBuffer: Uint8Array | ReadableStreamDefaultReader): Promise<UniversalEmbedder>;
+    /**
+     * Initializes the Wasm runtime and creates a UniversalEmbedder from a model path.
+     * @export
+     */
+    static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string | string): Promise<UniversalEmbedder>;
+    private constructor();
+    /**
+     * Performs embedding extraction on the input text.
+     * @export
+     */
+    embedText(text: string): Promise<UniversalEmbedderResult>;
+    /**
+     * Performs embedding extraction on raw image bytes.
+     * @export
+     */
+    embedImage(imageBytes: Uint8Array): Promise<UniversalEmbedderResult>;
+    /**
+     * Performs embedding extraction on audio float samples.
+     * @export
+     */
+    embedAudio(audioData: Float32Array): Promise<UniversalEmbedderResult>;
+    /**
+     * Performs embedding extraction on multimodal content parts.
+     * @export
+     */
+    embedContent(content: readonly ContentPart[]): Promise<UniversalEmbedderResult>;
+    /**
+     * Computes cosine similarity between two embeddings.
+     * @export
+     */
+    static cosineSimilarity(u: Embedding, v: Embedding): number;
+    /**
+     * Returns an {@link EmbeddingProvider} for this embedder.
+     * @export
+     */
+    getProvider(): EmbeddingProvider;
+    /**
+     * Shuts down the UniversalEmbedder and releases resources.
+     * @export
+     */
+    close(): void;
+}
+
+/**
+ * Copyright 2026 The MediaPipe Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/// <reference types="@webgpu/types" />
+/** Options for configuring the model asset and hardware accelerator. */
+export declare interface UniversalEmbedderBaseOptions {
+    /** The model asset buffer containing the .litertlm file. */
+    modelAssetBuffer?: Uint8Array | ReadableStreamDefaultReader;
+    /** The path to the model asset file. */
+    modelAssetPath?: string | string;
+    /** The hardware accelerator delegate to use ('CPU' or 'GPU'). */
+    delegate?: "CPU" | "GPU";
+    /** An optional pre-created GPUDevice to use for GPU inference. */
+    device?: GPUDevice;
+}
+
+/** Options to configure the MediaPipe Universal Embedder Task. */
+export declare interface UniversalEmbedderOptions {
+    /** Base options specifying the model asset and delegate. */
+    baseOptions: UniversalEmbedderBaseOptions;
+    /** Whether to L2-normalize the output embedding vector. Defaults to true. */
+    l2Normalize?: boolean;
+    /** Optional maximum sequence length (in tokens) for text encoder signatures. */
+    maxInputLength?: number;
+    /** Optional vision tokens per image for vision encoder signatures. */
+    visionTokensPerImage?: number;
+    /** Optional activation data type for model execution. */
+    activationDataType?: ActivationDataType;
+}
+
+/** Result returned by the Universal Embedder task. */
+export declare interface UniversalEmbedderResult {
+    /** The extracted embedding list. */
+    embeddings: Embedding[];
+}
+
+/**
+ * Declarations for the native UniversalEmbedder WebAssembly module.
+ *
+ * Using `declare interface` instructs Tsickle to generate Closure Compiler
+ * externs, preventing properties from being renamed by ADVANCED_OPTIMIZATIONS.
+ */
+export declare interface UniversalEmbedderWasmModule extends WasmModule {
+    preinitializedWebGPUDevice?: GPUDevice;
+    createUniversalEmbedder(modelPath: string, l2Normalize: boolean, useGpuBackend: boolean, maxInputLength: number, visionTokensPerImage: number, activationDataType: number): number;
+    universalEmbedder_embedText(handle: number, text: string): Float32Array;
+    universalEmbedder_embedImage(handle: number, imageBytes: Uint8Array | string): Float32Array;
+    universalEmbedder_embedAudio(handle: number, audioSamples: number[] | Float32Array): Float32Array;
+    universalEmbedder_createContentBuilder(): number;
+    universalEmbedder_builderAddText(builderHandle: number, text: string): void;
+    universalEmbedder_builderAddImage(builderHandle: number, imageBytes: Uint8Array | string): void;
+    universalEmbedder_builderAddAudio(builderHandle: number, audioSamples: number[] | Float32Array): void;
+    universalEmbedder_executeEmbedContent(handle: number, builderHandle: number): Float32Array;
+    universalEmbedder_freeContentBuilder(builderHandle: number): void;
+    universalEmbedder_close(handle: number): void;
+}
+
+/**
+ * A listener that receives a single element of vector-returning output packet.
+ * Receives one element at a time (in order). Once all elements are processed,
+ * the listener is invoked with `data` set to `unknown` and `done` set to true.
+ * Intended for internal usage.
+ */
+declare type VectorListener<T> = (data: T, done: boolean, timestamp: number) => void;
+
+/**
+ * Interface for vector storage and similarity search backends.
+ */
+export declare interface VectorStore {
+    /** Inserts or updates records in the vector store. */
+    upsert(records: readonly RetrievalRecord[]): Promise<void> | void;
+    /** Deletes records matching the specified IDs. */
+    delete(ids: readonly string[]): Promise<void> | void;
+    /** Deletes records matching the specified metadata filter. */
+    deleteByMetadata(metadataFilter: Record<string, string>): Promise<void> | void;
+    /** Searches top-K nearest records to the query embedding. */
+    search(queryEmbedding: Float32Array | readonly number[], topK: number, metadataFilter?: Record<string, string>): Promise<RetrievalRecord[]> | RetrievalRecord[];
+    /** Retrieves records matching the specified IDs by key. */
+    get(ids: readonly string[]): Promise<RetrievalRecord[]> | RetrievalRecord[];
+    /** Retrieves all unique record identifiers. */
+    getAllRecordIds(): Promise<string[]> | string[];
+    /** Deletes all records from the vector store. */
+    deleteAll(): Promise<void> | void;
+    /** Releases resources associated with the vector store. */
+    close(): void;
+}
+
+/**
+ * Copyright 2022 The MediaPipe Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** An object containing the locations of the Wasm assets */
+declare interface WasmFileset {
+    /** The path to the Wasm loader script. */
+    wasmLoaderPath: string;
+    /** The path to the Wasm binary. */
+    wasmBinaryPath: string;
+    /** The optional path to the asset loader script. */
+    assetLoaderPath?: string;
+    /** The optional path to the assets binary. */
+    assetBinaryPath?: string;
+}
+
+/**
+ * Declarations for Emscripten's WebAssembly Module behavior, so TS compiler
+ * doesn't break our various JS/C++ bridges. For internal usage.
+ */
+declare interface WasmModule {
+    canvas: HTMLCanvasElement | OffscreenCanvas | null;
+    HEAPU8: Uint8Array;
+    HEAPU32: Uint32Array;
+    HEAPF32: Float32Array;
+    HEAPF64: Float64Array;
+    FS_createDataFile: (parent: string, name: string, data: Uint8Array, canRead: boolean, canWrite: boolean, canOwn: boolean) => void;
+    FS_createPath: (parent: string, name: string, canRead: boolean, canWrite: boolean) => void;
+    FS_unlink(path: string): void;
+    gpuOriginForWebTexturesIsBottomLeft?: boolean;
+    errorListener?: ErrorListener;
+    _bindTextureToCanvas: () => boolean;
+    _changeBinaryGraph: (size: number, dataPtr: number) => void;
+    _changeTextGraph: (size: number, dataPtr: number) => void;
+    _closeGraph: () => void;
+    _free: (ptr: number) => void;
+    _malloc: (size: number) => number;
+    _processFrame: (width: number, height: number, timestamp: number) => void;
+    _setAutoRenderToScreen: (enabled: boolean) => void;
+    _waitUntilIdle: () => void;
+    dataFileDownloads?: {
+        [url: string]: {
+            loaded: number;
+            total: number;
+        };
+    };
+    stringToNewUTF8: (data: string) => number;
+    _bindTextureToStream: (streamNamePtr: number) => void;
+    _addBoundTextureToStream: (streamNamePtr: number, width: number, height: number, timestamp: number) => void;
+    _addBoolToInputStream: (data: boolean, streamNamePtr: number, timestamp: number) => void;
+    _addDoubleToInputStream: (data: number, streamNamePtr: number, timestamp: number) => void;
+    _addFloatToInputStream: (data: number, streamNamePtr: number, timestamp: number) => void;
+    _addIntToInputStream: (data: number, streamNamePtr: number, timestamp: number) => void;
+    _addUintToInputStream: (data: number, streamNamePtr: number, timestamp: number) => void;
+    _addStringToInputStream: (dataPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addBoolVectorToInputStream: (vecPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addDoubleVectorToInputStream: (vecPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addFloatVectorToInputStream: (vecPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addIntVectorToInputStream: (vecPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addUintVectorToInputStream: (vecPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addStringVectorToInputStream: (vecPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addFlatHashMapToInputStream: (keysPtr: number, valuesPtr: number, count: number, streamNamePtr: number, timestamp: number) => void;
+    _addRawDataSpanToInputStream: (dataPtr: number, dataSize: number, streamNamePtr: number, timestamp: number) => void;
+    _addProtoToInputStream: (dataPtr: number, dataSize: number, protoNamePtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addEmptyPacketToInputStream: (streamNamePtr: number, timestamp: number) => void;
+    _addBoolToInputSidePacket: (data: boolean, streamNamePtr: number) => void;
+    _addDoubleToInputSidePacket: (data: number, streamNamePtr: number) => void;
+    _addFloatToInputSidePacket: (data: number, streamNamePtr: number) => void;
+    _addIntToInputSidePacket: (data: number, streamNamePtr: number) => void;
+    _addUintToInputSidePacket: (data: number, streamNamePtr: number) => void;
+    _addStringToInputSidePacket: (dataPtr: number, streamNamePtr: number) => void;
+    _addRawDataSpanToInputSidePacket: (dataPtr: number, dataSize: number, streamNamePtr: number) => void;
+    _addProtoToInputSidePacket: (dataPtr: number, dataSize: number, protoNamePtr: number, streamNamePtr: number) => void;
+    _addBoolVectorToInputSidePacket: (vecPtr: number, streamNamePtr: number) => void;
+    _addDoubleVectorToInputSidePacket: (vecPtr: number, streamNamePtr: number) => void;
+    _addFloatVectorToInputSidePacket: (vecPtr: number, streamNamePtr: number) => void;
+    _addIntVectorToInputSidePacket: (vecPtr: number, streamNamePtr: number) => void;
+    _addUintVectorToInputSidePacket: (vecPtr: number, streamNamePtr: number) => void;
+    _addStringVectorToInputSidePacket: (vecPtr: number, streamNamePtr: number) => void;
+    _allocateBoolVector: (size: number) => number;
+    _allocateDoubleVector: (size: number) => number;
+    _allocateFloatVector: (size: number) => number;
+    _allocateIntVector: (size: number) => number;
+    _allocateUintVector: (size: number) => number;
+    _allocateStringVector: (size: number) => number;
+    _addBoolVectorEntry: (vecPtr: number, entry: boolean) => void;
+    _addDoubleVectorEntry: (vecPtr: number, entry: number) => void;
+    _addFloatVectorEntry: (vecPtr: number, entry: number) => void;
+    _addIntVectorEntry: (vecPtr: number, entry: number) => void;
+    _addUintVectorEntry: (vecPtr: number, entry: number) => void;
+    _addStringVectorEntry: (vecPtr: number, entryStringPtr: number) => void;
+    simpleListeners?: Record<string, SimpleListener<unknown> | VectorListener<unknown>>;
+    emptyPacketListeners?: Record<string, EmptyPacketListener>;
+    _attachBoolListener: (streamNamePtr: number) => void;
+    _attachBoolVectorListener: (streamNamePtr: number) => void;
+    _attachDoubleListener: (streamNamePtr: number) => void;
+    _attachDoubleVectorListener: (streamNamePtr: number) => void;
+    _attachFloatListener: (streamNamePtr: number) => void;
+    _attachFloatVectorListener: (streamNamePtr: number) => void;
+    _attachIntListener: (streamNamePtr: number) => void;
+    _attachIntVectorListener: (streamNamePtr: number) => void;
+    _attachUintListener: (streamNamePtr: number) => void;
+    _attachUintVectorListener: (streamNamePtr: number) => void;
+    _attachStringListener: (streamNamePtr: number) => void;
+    _attachStringVectorListener: (streamNamePtr: number) => void;
+    _attachProtoListener: (streamNamePtr: number, makeDeepCopy?: boolean) => void;
+    _attachProtoVectorListener: (streamNamePtr: number, makeDeepCopy?: boolean) => void;
+    _attachAudioListener: (streamNamePtr: number, makeDeepCopy?: boolean) => void;
+    _addAudioToInputStream: (dataPtr: number, numChannels: number, numSamples: number, streamNamePtr: number, timestamp: number) => void;
+    _configureAudio: (channels: number, samples: number, sampleRate: number, streamNamePtr: number, headerNamePtr: number) => void;
+    _getGraphConfig: (streamNamePtr: number, makeDeepCopy?: boolean) => void;
+    _processGl: (frameDataPtr: number) => number;
+}
+
+export { }