@mediapipe/tasks-text 0.1.0-alpha-1668420867

package/text.d.ts

@@ -0,0 +1,673 @@
+/// <reference types="@types/offscreencanvas" />
+
+import { Category } from '../../../../tasks/web/components/containers/category';
+import { Classifications } from '../../../../tasks/web/components/containers/classification_result';
+import { ClassifierOptions as TextClassifierOptions } from '../../../../tasks/web/core/classifier_options';
+import { ClassificationResult as TextClassifierResult } from '../../../../tasks/web/components/containers/classification_result';
+import { WasmLoaderOptions } from '../../../../tasks/web/core/wasm_loader_options';
+
+/** Listener to be passed in by user for handling output audio data. */
+declare type AudioOutputListener = (output: Float32Array) => void;
+
+export { Category }
+
+export { Classifications }
+
+/** A listener that will be invoked with an absl::StatusCode and message. */
+declare type ErrorListener = (code: number, message: string) => void;
+
+/**
+ * Valid types of image sources which we can run our WasmMediaPipeLib over.
+ */
+declare type ImageSource = HTMLCanvasElement | HTMLVideoElement | HTMLImageElement | ImageData | ImageBitmap;
+
+/** Base class for all MediaPipe Tasks. */
+declare abstract class TaskRunner extends WasmMediaPipeImageLib {
+    private processingErrors;
+    constructor(wasmModule: WasmModule);
+    /**
+     * Takes the raw data from a MediaPipe graph, and passes it to C++ to be run
+     * over the video stream. Will replace the previously running MediaPipe graph,
+     * if there is one.
+     * @param graphData The raw MediaPipe graph data, either in binary
+     *     protobuffer format (.binarypb), or else in raw text format (.pbtxt or
+     *     .textproto).
+     * @param isBinary This should be set to true if the graph is in
+     *     binary format, and false if it is in human-readable text format.
+     */
+    setGraph(graphData: Uint8Array, isBinary: boolean): void;
+    /**
+     * Forces all queued-up packets to be pushed through the MediaPipe graph as
+     * far as possible, performing all processing until no more processing can be
+     * done.
+     */
+    finishProcessing(): void;
+    /** Throws the error from the error listener if an error was raised. */
+    private handleErrors;
+}
+
+/** Performs Natural Language classification. */
+export declare class TextClassifier extends TaskRunner {
+    private classificationResult;
+    private readonly options;
+    /**
+     * Initializes the Wasm runtime and creates a new text classifier from the
+     * provided options.
+     * @param wasmLoaderOptions A configuration object that provides the location
+     *     of the Wasm binary and its loader.
+     * @param textClassifierOptions The options for the text classifier. Note that
+     *     either a path to the TFLite model or the model itself needs to be
+     *     provided (via `baseOptions`).
+     */
+    static createFromOptions(wasmLoaderOptions: WasmLoaderOptions, textClassifierOptions: TextClassifierOptions): Promise<TextClassifier>;
+    /**
+     * Initializes the Wasm runtime and creates a new text classifier based on the
+     * provided model asset buffer.
+     * @param wasmLoaderOptions A configuration object that provides the location
+     *     of the Wasm binary and its loader.
+     * @param modelAssetBuffer A binary representation of the model.
+     */
+    static createFromModelBuffer(wasmLoaderOptions: WasmLoaderOptions, modelAssetBuffer: Uint8Array): Promise<TextClassifier>;
+    /**
+     * Initializes the Wasm runtime and creates a new text classifier based on the
+     * path to the model asset.
+     * @param wasmLoaderOptions A configuration object that provides the location
+     *     of the Wasm binary and its loader.
+     * @param modelAssetPath The path to the model asset.
+     */
+    static createFromModelPath(wasmLoaderOptions: WasmLoaderOptions, modelAssetPath: string): Promise<TextClassifier>;
+    /**
+     * Sets new options for the text classifier.
+     *
+     * Calling `setOptions()` with a subset of options only affects those options.
+     * You can reset an option back to its default value by explicitly setting it
+     * to `undefined`.
+     *
+     * @param options The options for the text classifier.
+     */
+    setOptions(options: TextClassifierOptions): Promise<void>;
+    /**
+     * Performs Natural Language classification on the provided text and waits
+     * synchronously for the response.
+     *
+     * @param text The text to process.
+     * @return The classification result of the text
+     */
+    classify(text: string): TextClassifierResult;
+    /** Updates the MediaPipe graph configuration. */
+    private refreshGraph;
+}
+
+export { TextClassifierOptions }
+
+export { TextClassifierResult }
+
+declare const WasmMediaPipeImageLib: (new (...args: any[]) => {
+    registerModelResourcesGraphService(): void;
+    readonly wasmModule: WasmModule;
+    readonly hasMultiStreamSupport: boolean;
+    autoResizeCanvas: boolean;
+    audioPtr: number | null;
+    audioSize: number;
+    initializeGraph(graphFile: string): Promise<void>;
+    setGraphFromString(graphConfig: string): void;
+    setGraph(graphData: Uint8Array, isBinary: boolean): void;
+    configureAudio(numChannels: number, numSamples: number, sampleRate: number): void;
+    setAutoResizeCanvas(resize: boolean): void;
+    setAutoRenderToScreen(enabled: boolean): void;
+    bindTextureToStream(imageSource: ImageSource, streamNamePtr?: number | undefined): [number, number];
+    processGl(imageSource: ImageSource, timestamp: number): WebGLTexture | undefined;
+    wrapStringPtr(stringData: string, stringPtrFunc: (ptr: number) => void): void;
+    wrapStringPtrPtr(stringData: string[], ptrFunc: (ptr: number) => void): void;
+    setListener<T>(outputStreamName: string, callbackFcn: (data: T) => void): void;
+    setVectorListener<T_1>(outputStreamName: string, callbackFcn: (data: T_1[]) => void): void;
+    attachErrorListener(callbackFcn: (code: number, message: string) => void): void;
+    addAudioToStream(audioData: Float32Array, timestamp: number): void;
+    addGpuBufferToStream(imageSource: ImageSource, streamName: string, timestamp: number): void;
+    addBoolToStream(data: boolean, streamName: string, timestamp: number): void;
+    addDoubleToStream(data: number, streamName: string, timestamp: number): void;
+    addFloatToStream(data: number, streamName: string, timestamp: number): void;
+    addIntToStream(data: number, streamName: string, timestamp: number): void;
+    addStringToStream(data: string, streamName: string, timestamp: number): void;
+    addStringRecordToStream(data: Record<string, string>, streamName: string, timestamp: number): void;
+    addProtoToStream(data: Uint8Array, protoType: string, streamName: string, timestamp: number): void;
+    addBoolToInputSidePacket(data: boolean, sidePacketName: string): void;
+    addDoubleToInputSidePacket(data: number, sidePacketName: string): void;
+    addFloatToInputSidePacket(data: number, sidePacketName: string): void;
+    addIntToInputSidePacket(data: number, sidePacketName: string): void;
+    addStringToInputSidePacket(data: string, sidePacketName: string): void;
+    addProtoToInputSidePacket(data: Uint8Array, protoType: string, sidePacketName: string): void;
+    attachBoolListener(outputStreamName: string, callbackFcn: (data: boolean) => void): void;
+    attachBoolVectorListener(outputStreamName: string, callbackFcn: (data: boolean[]) => void): void;
+    attachIntListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    attachIntVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    attachDoubleListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    attachDoubleVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    attachFloatListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    attachFloatVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    attachStringListener(outputStreamName: string, callbackFcn: (data: string) => void): void;
+    attachStringVectorListener(outputStreamName: string, callbackFcn: (data: string[]) => void): void;
+    attachProtoListener(outputStreamName: string, callbackFcn: (data: Uint8Array) => void, makeDeepCopy?: boolean | undefined): void;
+    attachProtoVectorListener(outputStreamName: string, callbackFcn: (data: Uint8Array[]) => void, makeDeepCopy?: boolean | undefined): void;
+    setOnAudioOutput(audioOutputListener: AudioOutputListener): void;
+    finishProcessing(): void;
+}) & (new (...args: any[]) => {
+    addGpuBufferAsImageToStream(imageSource: ImageSource, streamName: string, timestamp: number): void;
+    readonly wasmModule: WasmModule;
+    readonly hasMultiStreamSupport: boolean;
+    autoResizeCanvas: boolean;
+    audioPtr: number | null;
+    audioSize: number;
+    initializeGraph(graphFile: string): Promise<void>;
+    setGraphFromString(graphConfig: string): void;
+    setGraph(graphData: Uint8Array, isBinary: boolean): void;
+    configureAudio(numChannels: number, numSamples: number, sampleRate: number): void;
+    setAutoResizeCanvas(resize: boolean): void; /**
+    * Forces all queued-up packets to be pushed through the MediaPipe graph as
+    * far as possible, performing all processing until no more processing can be
+    * done.
+    */
+    setAutoRenderToScreen(enabled: boolean): void;
+    bindTextureToStream(imageSource: ImageSource, streamNamePtr?: number | undefined): [number, number];
+    processGl(imageSource: ImageSource, timestamp: number): WebGLTexture | undefined;
+    wrapStringPtr(stringData: string, stringPtrFunc: (ptr: number) => void): void;
+    wrapStringPtrPtr(stringData: string[], ptrFunc: (ptr: number) => void): void;
+    setListener<T_2>(outputStreamName: string, callbackFcn: (data: T_2) => void): void;
+    setVectorListener<T_1_1>(outputStreamName: string, callbackFcn: (data: T_1_1[]) => void): void;
+    attachErrorListener(callbackFcn: (code: number, message: string) => void): void;
+    addAudioToStream(audioData: Float32Array, timestamp: number): void;
+    addGpuBufferToStream(imageSource: ImageSource, streamName: string, timestamp: number): void;
+    addBoolToStream(data: boolean, streamName: string, timestamp: number): void;
+    addDoubleToStream(data: number, streamName: string, timestamp: number): void;
+    addFloatToStream(data: number, streamName: string, timestamp: number): void;
+    addIntToStream(data: number, streamName: string, timestamp: number): void;
+    addStringToStream(data: string, streamName: string, timestamp: number): void;
+    addStringRecordToStream(data: Record<string, string>, streamName: string, timestamp: number): void;
+    addProtoToStream(data: Uint8Array, protoType: string, streamName: string, timestamp: number): void;
+    addBoolToInputSidePacket(data: boolean, sidePacketName: string): void;
+    addDoubleToInputSidePacket(data: number, sidePacketName: string): void;
+    addFloatToInputSidePacket(data: number, sidePacketName: string): void;
+    addIntToInputSidePacket(data: number, sidePacketName: string): void;
+    addStringToInputSidePacket(data: string, sidePacketName: string): void;
+    addProtoToInputSidePacket(data: Uint8Array, protoType: string, sidePacketName: string): void;
+    attachBoolListener(outputStreamName: string, callbackFcn: (data: boolean) => void): void;
+    attachBoolVectorListener(outputStreamName: string, callbackFcn: (data: boolean[]) => void): void;
+    attachIntListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    attachIntVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    attachDoubleListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    attachDoubleVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    attachFloatListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    attachFloatVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    attachStringListener(outputStreamName: string, callbackFcn: (data: string) => void): void;
+    attachStringVectorListener(outputStreamName: string, callbackFcn: (data: string[]) => void): void;
+    attachProtoListener(outputStreamName: string, callbackFcn: (data: Uint8Array) => void, makeDeepCopy?: boolean | undefined): void;
+    attachProtoVectorListener(outputStreamName: string, callbackFcn: (data: Uint8Array[]) => void, makeDeepCopy?: boolean | undefined): void;
+    setOnAudioOutput(audioOutputListener: AudioOutputListener): void;
+    finishProcessing(): void;
+}) & typeof WasmMediaPipeLib;
+
+/**
+ * Simple class to run an arbitrary image-in/image-out MediaPipe graph (i.e.
+ * as created by wasm_mediapipe_demo BUILD macro), and either render results
+ * into canvas, or else return the output WebGLTexture. Takes a WebAssembly
+ * Module (must be instantiated to self.Module).
+ */
+declare class WasmMediaPipeLib {
+    readonly wasmModule: WasmModule;
+    readonly hasMultiStreamSupport: boolean;
+    autoResizeCanvas: boolean;
+    audioPtr: number | null;
+    audioSize: number;
+    /**
+     * Creates a new MediaPipe WASM module. Must be called *after* wasm Module has
+     * initialized. Note that we take control of the GL canvas from here on out,
+     * and will resize it to fit input.
+     *
+     * @param module The underlying Wasm Module to use.
+     * @param glCanvas The type of the GL canvas to use, or `null` if no GL
+     *    canvas should be initialzed. Initializes an offscreen canvas if not
+     *    provided.
+     */
+    constructor(module: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
+    /**
+     * Convenience helper to load a MediaPipe graph from a file and pass it to
+     * setGraph.
+     * @param graphFile The url of the MediaPipe graph file to load.
+     */
+    initializeGraph(graphFile: string): Promise<void>;
+    /**
+     * Convenience helper for calling setGraph with a string representing a text
+     * proto config.
+     * @param graphConfig The text proto graph config, expected to be a string in
+     * default JavaScript UTF-16 format.
+     */
+    setGraphFromString(graphConfig: string): void;
+    /**
+     * Takes the raw data from a MediaPipe graph, and passes it to C++ to be run
+     * over the video stream. Will replace the previously running MediaPipe graph,
+     * if there is one.
+     * @param graphData The raw MediaPipe graph data, either in binary
+     *     protobuffer format (.binarypb), or else in raw text format (.pbtxt or
+     *     .textproto).
+     * @param isBinary This should be set to true if the graph is in
+     *     binary format, and false if it is in human-readable text format.
+     */
+    setGraph(graphData: Uint8Array, isBinary: boolean): void;
+    /**
+     * Configures the current graph to handle audio in a certain way. Must be
+     * called before the graph is set/started in order to use processAudio.
+     * @param numChannels The number of channels of audio input. Only 1
+     *     is supported for now.
+     * @param numSamples The number of samples that are taken in each
+     *     audio capture.
+     * @param sampleRate The rate, in Hz, of the sampling.
+     */
+    configureAudio(numChannels: number, numSamples: number, sampleRate: number): void;
+    /**
+     * Allows disabling automatic canvas resizing, in case clients want to control
+     * control this.
+     * @param resize True will re-enable automatic canvas resizing, while false
+     *     will disable the feature.
+     */
+    setAutoResizeCanvas(resize: boolean): void;
+    /**
+     * Allows disabling the automatic render-to-screen code, in case clients don't
+     * need/want this. In particular, this removes the requirement for pipelines
+     * to have access to GPU resources, as well as the requirement for graphs to
+     * have "input_frames_gpu" and "output_frames_gpu" streams defined, so pure
+     * CPU pipelines and non-video pipelines can be created.
+     * NOTE: This only affects future graph initializations (via setGraph or
+     *     initializeGraph), and does NOT affect the currently running graph, so
+     *     calls to this should be made *before* setGraph/initializeGraph for the
+     *     graph file being targeted.
+     * @param enabled True will re-enable automatic render-to-screen code and
+     *     cause GPU resources to once again be requested, while false will
+     *     disable the feature.
+     */
+    setAutoRenderToScreen(enabled: boolean): void;
+    /**
+     * Bind texture to our internal canvas, and upload image source to GPU.
+     * Returns tuple [width, height] of texture.  Intended for internal usage.
+     */
+    bindTextureToStream(imageSource: ImageSource, streamNamePtr?: number): [
+    number,
+    number
+    ];
+    /**
+     * Takes the raw data from a JS image source, and sends it to C++ to be
+     * processed, waiting synchronously for the response. Note that we will resize
+     * our GL canvas to fit the input, so input size should only change
+     * infrequently.
+     * @param imageSource An image source to process.
+     * @param timestamp The timestamp of the current frame, in ms.
+     * @return texture? The WebGL texture reference, if one was produced.
+     */
+    processGl(imageSource: ImageSource, timestamp: number): WebGLTexture | undefined;
+    /**
+     * Converts JavaScript string input parameters into C++ c-string pointers.
+     * See b/204830158 for more details. Intended for internal usage.
+     */
+    wrapStringPtr(stringData: string, stringPtrFunc: (ptr: number) => void): void;
+    /**
+     * Converts JavaScript string input parameters into C++ c-string pointers.
+     * See b/204830158 for more details.
+     */
+    wrapStringPtrPtr(stringData: string[], ptrFunc: (ptr: number) => void): void;
+    /**
+     * Ensures existence of the simple listeners table and registers the callback.
+     * Intended for internal usage.
+     */
+    setListener<T>(outputStreamName: string, callbackFcn: (data: T) => void): void;
+    /**
+     * Ensures existence of the vector listeners table and registers the callback.
+     * Intended for internal usage.
+     */
+    setVectorListener<T>(outputStreamName: string, callbackFcn: (data: T[]) => void): void;
+    /**
+     * Attaches a listener that will be invoked when the MediaPipe framework
+     * returns an error.
+     */
+    attachErrorListener(callbackFcn: (code: number, message: string) => void): void;
+    /**
+     * Takes the raw data from a JS audio capture array, and sends it to C++ to be
+     * processed.
+     * @param audioData An array of raw audio capture data, like
+     *     from a call to getChannelData on an AudioBuffer.
+     * @param timestamp The timestamp of the current frame, in ms.
+     */
+    addAudioToStream(audioData: Float32Array, timestamp: number): void;
+    /**
+     * Takes the relevant information from the HTML video or image element, and
+     * passes it into the WebGL-based graph for processing on the given stream at
+     * the given timestamp. Can be used for additional auxiliary GpuBuffer input
+     * streams. Processing will not occur until a blocking call (like
+     * processVideoGl or finishProcessing) is made. For use with
+     * 'gl_graph_runner_internal_multi_input'.
+     * @param imageSource Reference to the video frame we wish to add into our
+     *     graph.
+     * @param streamName The name of the MediaPipe graph stream to add the frame
+     *     to.
+     * @param timestamp The timestamp of the input frame, in ms.
+     */
+    addGpuBufferToStream(imageSource: ImageSource, streamName: string, timestamp: number): void;
+    /**
+     * Sends a boolean packet into the specified stream at the given timestamp.
+     * @param data The boolean data to send.
+     * @param streamName The name of the graph input stream to send data into.
+     * @param timestamp The timestamp of the input data, in ms.
+     */
+    addBoolToStream(data: boolean, streamName: string, timestamp: number): void;
+    /**
+     * Sends a double packet into the specified stream at the given timestamp.
+     * @param data The double data to send.
+     * @param streamName The name of the graph input stream to send data into.
+     * @param timestamp The timestamp of the input data, in ms.
+     */
+    addDoubleToStream(data: number, streamName: string, timestamp: number): void;
+    /**
+     * Sends a float packet into the specified stream at the given timestamp.
+     * @param data The float data to send.
+     * @param streamName The name of the graph input stream to send data into.
+     * @param timestamp The timestamp of the input data, in ms.
+     */
+    addFloatToStream(data: number, streamName: string, timestamp: number): void;
+    /**
+     * Sends an integer packet into the specified stream at the given timestamp.
+     * @param data The integer data to send.
+     * @param streamName The name of the graph input stream to send data into.
+     * @param timestamp The timestamp of the input data, in ms.
+     */
+    addIntToStream(data: number, streamName: string, timestamp: number): void;
+    /**
+     * Sends a string packet into the specified stream at the given timestamp.
+     * @param data The string data to send.
+     * @param streamName The name of the graph input stream to send data into.
+     * @param timestamp The timestamp of the input data, in ms.
+     */
+    addStringToStream(data: string, streamName: string, timestamp: number): void;
+    /**
+     * Sends a Record<string, string> packet into the specified stream at the
+     * given timestamp.
+     * @param data The records to send (will become a
+     *             std::flat_hash_map<std::string, std::string).
+     * @param streamName The name of the graph input stream to send data into.
+     * @param timestamp The timestamp of the input data, in ms.
+     */
+    addStringRecordToStream(data: Record<string, string>, streamName: string, timestamp: number): void;
+    /**
+     * Sends a serialized protobuffer packet into the specified stream at the
+     *     given timestamp, to be parsed into the specified protobuffer type.
+     * @param data The binary (serialized) raw protobuffer data.
+     * @param protoType The C++ namespaced type this protobuffer data corresponds
+     *     to. It will be converted to this type when output as a packet into the
+     *     graph.
+     * @param streamName The name of the graph input stream to send data into.
+     * @param timestamp The timestamp of the input data, in ms.
+     */
+    addProtoToStream(data: Uint8Array, protoType: string, streamName: string, timestamp: number): void;
+    /**
+     * Attaches a boolean packet to the specified input_side_packet.
+     * @param data The boolean data to send.
+     * @param sidePacketName The name of the graph input side packet to send data
+     *     into.
+     */
+    addBoolToInputSidePacket(data: boolean, sidePacketName: string): void;
+    /**
+     * Attaches a double packet to the specified input_side_packet.
+     * @param data The double data to send.
+     * @param sidePacketName The name of the graph input side packet to send data
+     *     into.
+     */
+    addDoubleToInputSidePacket(data: number, sidePacketName: string): void;
+    /**
+     * Attaches a float packet to the specified input_side_packet.
+     * @param data The float data to send.
+     * @param sidePacketName The name of the graph input side packet to send data
+     *     into.
+     */
+    addFloatToInputSidePacket(data: number, sidePacketName: string): void;
+    /**
+     * Attaches a integer packet to the specified input_side_packet.
+     * @param data The integer data to send.
+     * @param sidePacketName The name of the graph input side packet to send data
+     *     into.
+     */
+    addIntToInputSidePacket(data: number, sidePacketName: string): void;
+    /**
+     * Attaches a string packet to the specified input_side_packet.
+     * @param data The string data to send.
+     * @param sidePacketName The name of the graph input side packet to send data
+     *     into.
+     */
+    addStringToInputSidePacket(data: string, sidePacketName: string): void;
+    /**
+     * Attaches a serialized proto packet to the specified input_side_packet.
+     * @param data The binary (serialized) raw protobuffer data.
+     * @param protoType The C++ namespaced type this protobuffer data corresponds
+     *     to. It will be converted to this type for use in the graph.
+     * @param sidePacketName The name of the graph input side packet to send data
+     *     into.
+     */
+    addProtoToInputSidePacket(data: Uint8Array, protoType: string, sidePacketName: string): void;
+    /**
+     * Attaches a boolean packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab boolean
+     *     data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachBoolListener(outputStreamName: string, callbackFcn: (data: boolean) => void): void;
+    /**
+     * Attaches a bool[] packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab
+     *     std::vector<bool> data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachBoolVectorListener(outputStreamName: string, callbackFcn: (data: boolean[]) => void): void;
+    /**
+     * Attaches an int packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab int
+     *     data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachIntListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    /**
+     * Attaches an int[] packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab
+     *     std::vector<int> data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachIntVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    /**
+     * Attaches a double packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab double
+     *     data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachDoubleListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    /**
+     * Attaches a double[] packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab
+     *     std::vector<double> data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachDoubleVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    /**
+     * Attaches a float packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab float
+     *     data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachFloatListener(outputStreamName: string, callbackFcn: (data: number) => void): void;
+    /**
+     * Attaches a float[] packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab
+     *     std::vector<float> data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachFloatVectorListener(outputStreamName: string, callbackFcn: (data: number[]) => void): void;
+    /**
+     * Attaches a string packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab string
+     *     data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachStringListener(outputStreamName: string, callbackFcn: (data: string) => void): void;
+    /**
+     * Attaches a string[] packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab
+     *     std::vector<std::string> data from.
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that the data is only guaranteed to exist for the
+     *     duration of the callback, and the callback will be called inline, so it
+     *     should not perform overly complicated (or any async) behavior.
+     */
+    attachStringVectorListener(outputStreamName: string, callbackFcn: (data: string[]) => void): void;
+    /**
+     * Attaches a serialized proto packet listener to the specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab binary
+     *     serialized proto data from (in Uint8Array format).
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that by default the data is only guaranteed to
+     *     exist for the duration of the callback, and the callback will be called
+     *     inline, so it should not perform overly complicated (or any async)
+     *     behavior. If the proto data needs to be able to outlive the call, you
+     *     may set the optional makeDeepCopy parameter to true, or can manually
+     *     deep-copy the data yourself.
+     * @param makeDeepCopy Optional convenience parameter which, if set to true,
+     *     will override the default memory management behavior and make a deep
+     *     copy of the underlying data, rather than just returning a view into the
+     *     C++-managed memory. At the cost of a data copy, this allows the
+     *     returned data to outlive the callback lifetime (and it will be cleaned
+     *     up automatically by JS garbage collection whenever the user is finished
+     *     with it).
+     */
+    attachProtoListener(outputStreamName: string, callbackFcn: (data: Uint8Array) => void, makeDeepCopy?: boolean): void;
+    /**
+     * Attaches a listener for an array of serialized proto packets to the
+     * specified output_stream.
+     * @param outputStreamName The name of the graph output stream to grab a
+     *     vector of binary serialized proto data from (in Uint8Array[] format).
+     * @param callbackFcn The function that will be called back with the data, as
+     *     it is received.  Note that by default the data is only guaranteed to
+     *     exist for the duration of the callback, and the callback will be called
+     *     inline, so it should not perform overly complicated (or any async)
+     *     behavior. If the proto data needs to be able to outlive the call, you
+     *     may set the optional makeDeepCopy parameter to true, or can manually
+     *     deep-copy the data yourself.
+     * @param makeDeepCopy Optional convenience parameter which, if set to true,
+     *     will override the default memory management behavior and make a deep
+     *     copy of the underlying data, rather than just returning a view into the
+     *     C++-managed memory. At the cost of a data copy, this allows the
+     *     returned data to outlive the callback lifetime (and it will be cleaned
+     *     up automatically by JS garbage collection whenever the user is finished
+     *     with it).
+     */
+    attachProtoVectorListener(outputStreamName: string, callbackFcn: (data: Uint8Array[]) => void, makeDeepCopy?: boolean): void;
+    /**
+     * Sets a listener to be called back with audio output packet data, as a
+     * Float32Array, when graph has finished processing it.
+     * @param audioOutputListener The caller's listener function.
+     */
+    setOnAudioOutput(audioOutputListener: AudioOutputListener): void;
+    /**
+     * Forces all queued-up packets to be pushed through the MediaPipe graph as
+     * far as possible, performing all processing until no more processing can be
+     * done.
+     */
+    finishProcessing(): void;
+}
+
+/**
+ * Declarations for Emscripten's WebAssembly Module behavior, so TS compiler
+ * doesn't break our JS/C++ bridge.
+ */
+declare interface WasmModule {
+    canvas: HTMLCanvasElement | OffscreenCanvas | null;
+    HEAPU8: Uint8Array;
+    HEAPU32: Uint32Array;
+    HEAPF32: Float32Array;
+    HEAPF64: Float64Array;
+    errorListener?: ErrorListener;
+    _bindTextureToCanvas: () => boolean;
+    _changeBinaryGraph: (size: number, dataPtr: number) => void;
+    _changeTextGraph: (size: number, dataPtr: number) => void;
+    _configureAudio: (channels: number, samples: number, sampleRate: number) => void;
+    _free: (ptr: number) => void;
+    _malloc: (size: number) => number;
+    _processAudio: (dataPtr: number, timestamp: number) => void;
+    _processFrame: (width: number, height: number, timestamp: number) => void;
+    _setAutoRenderToScreen: (enabled: boolean) => void;
+    _waitUntilIdle: () => void;
+    dataFileDownloads?: {
+        [url: string]: {
+            loaded: number;
+            total: number;
+        };
+    };
+    onAudioOutput?: AudioOutputListener;
+    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;
+    _addStringToInputStream: (dataPtr: number, streamNamePtr: number, timestamp: number) => void;
+    _addFlatHashMapToInputStream: (keysPtr: number, valuesPtr: number, count: number, streamNamePtr: number, timestamp: number) => void;
+    _addProtoToInputStream: (dataPtr: number, dataSize: number, protoNamePtr: number, 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;
+    _addStringToInputSidePacket: (dataPtr: number, streamNamePtr: number) => void;
+    _addProtoToInputSidePacket: (dataPtr: number, dataSize: number, protoNamePtr: number, streamNamePtr: number) => void;
+    simpleListeners?: {
+        [outputStreamName: string]: (data: unknown) => void;
+    };
+    vectorListeners?: {
+        [outputStreamName: string]: (data: unknown, index: number, length: number) => void;
+    };
+    _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;
+    _attachStringListener: (streamNamePtr: number) => void;
+    _attachStringVectorListener: (streamNamePtr: number) => void;
+    _attachProtoListener: (streamNamePtr: number, makeDeepCopy?: boolean) => void;
+    _attachProtoVectorListener: (streamNamePtr: number, makeDeepCopy?: boolean) => void;
+    _attachAudioOutputListener: () => void;
+    _processGl: (frameDataPtr: number) => number;
+}
+
+export { }