@mediapipe/tasks-vision 0.1.0-alpha-1668420867

package/vision.d.ts

@@ -0,0 +1,907 @@
+/// <reference types="@types/offscreencanvas" />
+
+import { BaseOptions } from '../../../../tasks/web/core/base_options';
+import { Category } from '../../../../tasks/web/components/containers/category';
+import { Classifications } from '../../../../tasks/web/components/containers/classification_result';
+import { ClassifierOptions as ImageClassifierOptions } from '../../../../tasks/web/core/classifier_options';
+import { ClassificationResult as ImageClassifierResult } from '../../../../tasks/web/components/containers/classification_result';
+import { Landmark } from '../../../../tasks/web/components/containers/landmark';
+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;
+
+/** An integer bounding box, axis aligned. */
+export declare interface BoundingBox {
+    /** The X coordinate of the top-left corner, in pixels. */
+    originX: number;
+    /** The Y coordinate of the top-left corner, in pixels. */
+    originY: number;
+    /** The width of the bounding box, in pixels. */
+    width: number;
+    /** The height of the bounding box, in pixels. */
+    height: number;
+}
+
+export { Category }
+
+export { Classifications }
+
+/** Represents one object detected by the `ObjectDetector`. */
+export declare interface Detection {
+    /** A list of `Category` objects. */
+    categories: Category[];
+    /** The bounding box of the detected objects. */
+    boundingBox?: BoundingBox;
+}
+
+/** A listener that will be invoked with an absl::StatusCode and message. */
+declare type ErrorListener = (code: number, message: string) => void;
+
+/** Performs hand gesture recognition on images. */
+export declare class GestureRecognizer extends TaskRunner {
+    private gestures;
+    private landmarks;
+    private worldLandmarks;
+    private handednesses;
+    private readonly options;
+    private readonly handLandmarkerGraphOptions;
+    private readonly handLandmarksDetectorGraphOptions;
+    private readonly handDetectorGraphOptions;
+    private readonly handGestureRecognizerGraphOptions;
+    /**
+     * Initializes the Wasm runtime and creates a new gesture recognizer from the
+     * provided options.
+     * @param wasmLoaderOptions A configuration object that provides the location
+     *     of the Wasm binary and its loader.
+     * @param gestureRecognizerOptions The options for the gesture recognizer.
+     *     Note that either a path to the model asset or a model buffer needs to
+     *     be provided (via `baseOptions`).
+     */
+    static createFromOptions(wasmLoaderOptions: WasmLoaderOptions, gestureRecognizerOptions: GestureRecognizerOptions): Promise<GestureRecognizer>;
+    /**
+     * Initializes the Wasm runtime and creates a new gesture recognizer 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<GestureRecognizer>;
+    /**
+     * Initializes the Wasm runtime and creates a new gesture recognizer 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<GestureRecognizer>;
+    constructor(wasmModule: WasmModule);
+    /**
+     * Sets new options for the gesture recognizer.
+     *
+     * 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 gesture recognizer.
+     */
+    setOptions(options: GestureRecognizerOptions): Promise<void>;
+    /**
+     * Performs gesture recognition on the provided single image and waits
+     * synchronously for the response.
+     * @param imageSource An image source to process.
+     * @param timestamp The timestamp of the current frame, in ms. If not
+     *    provided, defaults to `performance.now()`.
+     * @return The detected gestures.
+     */
+    recognize(imageSource: ImageSource, timestamp?: number): GestureRecognizerResult;
+    /** Sets the default values for the graph. */
+    private initDefaults;
+    /** Converts the proto data to a Category[][] structure. */
+    private toJsCategories;
+    /** Converts raw data into a landmark, and adds it to our landmarks list. */
+    private addJsLandmarks;
+    /**
+     * Converts raw data into a landmark, and adds it to our worldLandmarks
+     * list.
+     */
+    private adddJsWorldLandmarks;
+    /** Updates the MediaPipe graph configuration. */
+    private refreshGraph;
+}
+
+/** Options to configure the MediaPipe Gesture Recognizer Task */
+export declare interface GestureRecognizerOptions {
+    /** Options to configure the loading of the model assets. */
+    baseOptions?: BaseOptions;
+    /**
+     * The maximum number of hands can be detected by the GestureRecognizer.
+     * Defaults to 1.
+     */
+    numHands?: number | undefined;
+    /**
+     * The minimum confidence score for the hand detection to be considered
+     * successful. Defaults to 0.5.
+     */
+    minHandDetectionConfidence?: number | undefined;
+    /**
+     * The minimum confidence score of hand presence score in the hand landmark
+     * detection. Defaults to 0.5.
+     */
+    minHandPresenceConfidence?: number | undefined;
+    /**
+     * The minimum confidence score for the hand tracking to be considered
+     * successful. Defaults to 0.5.
+     */
+    minTrackingConfidence?: number | undefined;
+    /**
+     * Sets the optional `ClassifierOptions` controling the canned gestures
+     * classifier, such as score threshold, allow list and deny list of gestures.
+     * The categories for canned gesture
+     * classifiers are: ["None", "Closed_Fist", "Open_Palm", "Pointing_Up",
+     * "Thumb_Down", "Thumb_Up", "Victory", "ILoveYou"]
+     */
+    cannedGesturesClassifierOptions?: ImageClassifierOptions | undefined;
+    /**
+     * Options for configuring the custom gestures classifier, such as score
+     * threshold, allow list and deny list of gestures.
+     */
+    customGesturesClassifierOptions?: ImageClassifierOptions | undefined;
+}
+
+/**
+ * Represents the gesture recognition results generated by `GestureRecognizer`.
+ */
+export declare interface GestureRecognizerResult {
+    /** Hand landmarks of detected hands. */
+    landmarks: Landmark[][];
+    /** Hand landmarks in world coordniates of detected hands. */
+    worldLandmarks: Landmark[][];
+    /** Handedness of detected hands. */
+    handednesses: Category[][];
+    /** Recognized hand gestures of detected hands */
+    gestures: Category[][];
+}
+
+/** Performs classification on images. */
+export declare class ImageClassifier extends TaskRunner {
+    private classificationResult;
+    private readonly options;
+    /**
+     * Initializes the Wasm runtime and creates a new image classifier from the
+     * provided options.
+     * @param wasmLoaderOptions A configuration object that provides the location
+     *     of the Wasm binary and its loader.
+     * @param imageClassifierOptions The options for the image classifier. Note
+     *     that either a path to the model asset or a model buffer needs to be
+     *     provided (via `baseOptions`).
+     */
+    static createFromOptions(wasmLoaderOptions: WasmLoaderOptions, imageClassifierOptions: ImageClassifierOptions): Promise<ImageClassifier>;
+    /**
+     * Initializes the Wasm runtime and creates a new image 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<ImageClassifier>;
+    /**
+     * Initializes the Wasm runtime and creates a new image 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<ImageClassifier>;
+    /**
+     * Sets new options for the image 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 image classifier.
+     */
+    setOptions(options: ImageClassifierOptions): Promise<void>;
+    /**
+     * Performs image classification on the provided image and waits synchronously
+     * for the response.
+     *
+     * @param imageSource An image source to process.
+     * @param timestamp The timestamp of the current frame, in ms. If not
+     *     provided, defaults to `performance.now()`.
+     * @return The classification result of the image
+     */
+    classify(imageSource: ImageSource, timestamp?: number): ImageClassifierResult;
+    /** Updates the MediaPipe graph configuration. */
+    private refreshGraph;
+}
+
+export { ImageClassifierOptions }
+
+export { ImageClassifierResult }
+
+/**
+ * Valid types of image sources which we can run our WasmMediaPipeLib over.
+ */
+export declare type ImageSource = HTMLCanvasElement | HTMLVideoElement | HTMLImageElement | ImageData | ImageBitmap;
+
+/** Performs object detection on images. */
+export declare class ObjectDetector extends TaskRunner {
+    private detections;
+    private readonly options;
+    /**
+     * Initializes the Wasm runtime and creates a new object detector from the
+     * provided options.
+     * @param wasmLoaderOptions A configuration object that provides the location
+     *     of the Wasm binary and its loader.
+     * @param objectDetectorOptions The options for the Object Detector. Note that
+     *     either a path to the model asset or a model buffer needs to be
+     *     provided (via `baseOptions`).
+     */
+    static createFromOptions(wasmLoaderOptions: WasmLoaderOptions, objectDetectorOptions: ObjectDetectorOptions): Promise<ObjectDetector>;
+    /**
+     * Initializes the Wasm runtime and creates a new object detector 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<ObjectDetector>;
+    /**
+     * Initializes the Wasm runtime and creates a new object detector 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<ObjectDetector>;
+    /**
+     * Sets new options for the object detector.
+     *
+     * 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 object detector.
+     */
+    setOptions(options: ObjectDetectorOptions): Promise<void>;
+    /**
+     * Performs object detection on the provided single image and waits
+     * synchronously for the response.
+     * @param imageSource An image source to process.
+     * @param timestamp The timestamp of the current frame, in ms. If not
+     *    provided, defaults to `performance.now()`.
+     * @return The list of detected objects
+     */
+    detect(imageSource: ImageSource, timestamp?: number): Detection[];
+    /** Converts raw data into a Detection, and adds it to our detection list. */
+    private addJsObjectDetections;
+    /** Updates the MediaPipe graph configuration. */
+    private refreshGraph;
+}
+
+/** Options to configure the MediaPipe Object Detector Task */
+export declare interface ObjectDetectorOptions {
+    /** Options to configure the loading of the model assets. */
+    baseOptions?: BaseOptions;
+    /**
+     * The locale to use for display names specified through the TFLite Model
+     * Metadata, if any. Defaults to English.
+     */
+    displayNamesLocale?: string | undefined;
+    /** The maximum number of top-scored detection results to return. */
+    maxResults?: number | undefined;
+    /**
+     * Overrides the value provided in the model metadata. Results below this
+     * value are rejected.
+     */
+    scoreThreshold?: number | undefined;
+    /**
+     * Allowlist of category names. If non-empty, detection results whose category
+     * name is not in this set will be filtered out. Duplicate or unknown category
+     * names are ignored. Mutually exclusive with `categoryDenylist`.
+     */
+    categoryAllowlist?: string[] | undefined;
+    /**
+     * Denylist of category names. If non-empty, detection results whose category
+     * name is in this set will be filtered out. Duplicate or unknown category
+     * names are ignored. Mutually exclusive with `categoryAllowlist`.
+     */
+    categoryDenylist?: string[] | undefined;
+}
+
+/** 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;
+}
+
+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 { }