@mediapipe/tasks-vision 0.1.0-alpha-1 → 0.1.0-alpha-2

package/vision.d.ts

@@ -1,49 +1,3 @@
-/// <reference types="@types/offscreencanvas" />
-
-import * as jspb from 'google-protobuf';
-
-declare class Acceleration extends jspb.Message {
-    hasXnnpack(): boolean;
-    clearXnnpack(): void;
-    getXnnpack(): mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.Xnnpack | undefined;
-    setXnnpack(value?: mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.Xnnpack): void;
-
-    hasGpu(): boolean;
-    clearGpu(): void;
-    getGpu(): mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.Gpu | undefined;
-    setGpu(value?: mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.Gpu): void;
-
-    hasTflite(): boolean;
-    clearTflite(): void;
-    getTflite(): mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.TfLite | undefined;
-    setTflite(value?: mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.TfLite): void;
-
-    getDelegateCase(): Acceleration.DelegateCase;
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): Acceleration.AsObject;
-    static toObject(includeInstance: boolean, msg: Acceleration): Acceleration.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: Acceleration, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): Acceleration;
-    static deserializeBinaryFromReader(message: Acceleration, reader: jspb.BinaryReader): Acceleration;
-}
-
-declare namespace Acceleration {
-    type AsObject = {
-        xnnpack?: mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.Xnnpack.AsObject,
-        gpu?: mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.Gpu.AsObject,
-        tflite?: mediapipe_calculators_tensor_inference_calculator_pb.InferenceCalculatorOptions.Delegate.TfLite.AsObject,
-    }
-
-    enum DelegateCase {
-        DELEGATE_NOT_SET = 0,
-        XNNPACK = 1,
-        GPU = 2,
-        TFLITE = 4,
-    }
-}
-
 /**
  * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
  *
@@ -60,7 +14,7 @@ declare namespace Acceleration {
  * limitations under the License.
  */
 /** Options to configure MediaPipe model loading and processing. */
-declare interface BaseOptions {
+declare interface BaseOptions_2 {
     /**
      * The model path to the model asset file. Only one of `modelAssetPath` or
      * `modelAssetBuffer` can be set.
@@ -72,41 +26,7 @@ declare interface BaseOptions {
      */
     modelAssetBuffer?: Uint8Array | undefined;
     /** Overrides the default backend to use for the provided model. */
-    delegate?: 'cpu' | 'gpu' | undefined;
-}
-
-declare class BaseOptions_2 extends jspb.Message {
-    hasModelAsset(): boolean;
-    clearModelAsset(): void;
-    getModelAsset(): mediapipe_tasks_cc_core_proto_external_file_pb.ExternalFile | undefined;
-    setModelAsset(value?: mediapipe_tasks_cc_core_proto_external_file_pb.ExternalFile): void;
-
-    hasUseStreamMode(): boolean;
-    clearUseStreamMode(): void;
-    getUseStreamMode(): boolean | undefined;
-    setUseStreamMode(value: boolean): void;
-
-    hasAcceleration(): boolean;
-    clearAcceleration(): void;
-    getAcceleration(): mediapipe_tasks_cc_core_proto_acceleration_pb.Acceleration | undefined;
-    setAcceleration(value?: mediapipe_tasks_cc_core_proto_acceleration_pb.Acceleration): void;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): BaseOptions_2.AsObject;
-    static toObject(includeInstance: boolean, msg: BaseOptions_2): BaseOptions_2.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BaseOptions_2, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BaseOptions_2;
-    static deserializeBinaryFromReader(message: BaseOptions_2, reader: jspb.BinaryReader): BaseOptions_2;
-}
-
-declare namespace BaseOptions_2 {
-    type AsObject = {
-        modelAsset?: mediapipe_tasks_cc_core_proto_external_file_pb.ExternalFile.AsObject,
-        useStreamMode?: boolean,
-        acceleration?: mediapipe_tasks_cc_core_proto_acceleration_pb.Acceleration.AsObject,
-    }
+    delegate?: "CPU" | "GPU" | undefined;
 }
 
 /** An integer bounding box, axis aligned. */
@@ -304,113 +224,6 @@ export declare interface Embedding {
     headName: string;
 }
 
-/** A listener that will be invoked with an absl::StatusCode and message. */
-declare type ErrorListener = (code: number, message: string) => void;
-
-declare class ExternalFile extends jspb.Message {
-    hasFileContent(): boolean;
-    clearFileContent(): void;
-    getFileContent(): Uint8Array | string;
-    getFileContent_asU8(): Uint8Array;
-    getFileContent_asB64(): string;
-    setFileContent(value: Uint8Array | string): void;
-
-    hasFileName(): boolean;
-    clearFileName(): void;
-    getFileName(): string | undefined;
-    setFileName(value: string): void;
-
-    hasFileDescriptorMeta(): boolean;
-    clearFileDescriptorMeta(): void;
-    getFileDescriptorMeta(): FileDescriptorMeta | undefined;
-    setFileDescriptorMeta(value?: FileDescriptorMeta): void;
-
-    hasFilePointerMeta(): boolean;
-    clearFilePointerMeta(): void;
-    getFilePointerMeta(): FilePointerMeta | undefined;
-    setFilePointerMeta(value?: FilePointerMeta): void;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ExternalFile.AsObject;
-    static toObject(includeInstance: boolean, msg: ExternalFile): ExternalFile.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ExternalFile, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ExternalFile;
-    static deserializeBinaryFromReader(message: ExternalFile, reader: jspb.BinaryReader): ExternalFile;
-}
-
-declare namespace ExternalFile {
-    type AsObject = {
-        fileContent: Uint8Array | string,
-        fileName?: string,
-        fileDescriptorMeta?: FileDescriptorMeta.AsObject,
-        filePointerMeta?: FilePointerMeta.AsObject,
-    }
-}
-
-declare class FileDescriptorMeta extends jspb.Message {
-    hasFd(): boolean;
-    clearFd(): void;
-    getFd(): number | undefined;
-    setFd(value: number): void;
-
-    hasLength(): boolean;
-    clearLength(): void;
-    getLength(): number | undefined;
-    setLength(value: number): void;
-
-    hasOffset(): boolean;
-    clearOffset(): void;
-    getOffset(): number | undefined;
-    setOffset(value: number): void;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): FileDescriptorMeta.AsObject;
-    static toObject(includeInstance: boolean, msg: FileDescriptorMeta): FileDescriptorMeta.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: FileDescriptorMeta, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): FileDescriptorMeta;
-    static deserializeBinaryFromReader(message: FileDescriptorMeta, reader: jspb.BinaryReader): FileDescriptorMeta;
-}
-
-declare namespace FileDescriptorMeta {
-    type AsObject = {
-        fd?: number,
-        length?: number,
-        offset?: number,
-    }
-}
-
-declare class FilePointerMeta extends jspb.Message {
-    hasPointer(): boolean;
-    clearPointer(): void;
-    getPointer(): number | undefined;
-    setPointer(value: number): void;
-
-    hasLength(): boolean;
-    clearLength(): void;
-    getLength(): number | undefined;
-    setLength(value: number): void;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): FilePointerMeta.AsObject;
-    static toObject(includeInstance: boolean, msg: FilePointerMeta): FilePointerMeta.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: FilePointerMeta, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): FilePointerMeta;
-    static deserializeBinaryFromReader(message: FilePointerMeta, reader: jspb.BinaryReader): FilePointerMeta;
-}
-
-declare namespace FilePointerMeta {
-    type AsObject = {
-        pointer?: number,
-        length?: number,
-    }
-}
-
 /**
  * Resolves the files required for the MediaPipe Task APIs.
  *
@@ -464,16 +277,7 @@ export declare class FilesetResolver {
 }
 
 /** Performs hand gesture recognition on images. */
-export declare class GestureRecognizer extends VisionTaskRunner<GestureRecognizerResult> {
-    private gestures;
-    private landmarks;
-    private worldLandmarks;
-    private handednesses;
-    private readonly options;
-    private readonly handLandmarkerGraphOptions;
-    private readonly handLandmarksDetectorGraphOptions;
-    private readonly handDetectorGraphOptions;
-    private readonly handGestureRecognizerGraphOptions;
+export declare class GestureRecognizer extends VisionTaskRunner {
     /**
      * Initializes the Wasm runtime and creates a new gesture recognizer from the
      * provided options.
@@ -500,9 +304,7 @@ export declare class GestureRecognizer extends VisionTaskRunner<GestureRecognize
      * @param modelAssetPath The path to the model asset.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<GestureRecognizer>;
-    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
-    protected get baseOptions(): BaseOptions_2;
-    protected set baseOptions(proto: BaseOptions_2);
+    private constructor();
     /**
      * Sets new options for the gesture recognizer.
      *
@@ -519,9 +321,11 @@ export declare class GestureRecognizer extends VisionTaskRunner<GestureRecognize
      * GestureRecognizer is created with running mode `image`.
      *
      * @param image A single image to process.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The detected gestures.
      */
-    recognize(image: ImageSource): GestureRecognizerResult;
+    recognize(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): GestureRecognizerResult;
     /**
      * Performs gesture recognition on the provided video frame and waits
      * synchronously for the response. Only use this method when the
@@ -529,24 +333,11 @@ export declare class GestureRecognizer extends VisionTaskRunner<GestureRecognize
      *
      * @param videoFrame A video frame to process.
      * @param timestamp The timestamp of the current frame, in ms.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The detected gestures.
      */
-    recognizeForVideo(videoFrame: ImageSource, timestamp: number): GestureRecognizerResult;
-    /** Runs the gesture recognition and blocks on the response. */
-    protected process(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;
+    recognizeForVideo(videoFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): GestureRecognizerResult;
 }
 
 /** Options to configure the MediaPipe Gesture Recognizer Task */
@@ -596,569 +387,16 @@ export declare interface GestureRecognizerResult {
     worldLandmarks: Landmark[][];
     /** Handedness of detected hands. */
     handednesses: Category[][];
-    /** Recognized hand gestures of detected hands */
-    gestures: Category[][];
-}
-
-/**
- * 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 GraphRunner {
-    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 processing in a certain way
-     * for all its audio input streams. Additionally can configure audio headers
-     * (both input side packets as well as input stream headers), but these
-     * configurations only take effect if called before the graph is set/started.
-     * @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.
-     * @param streamName The optional name of the input stream to additionally
-     *     configure with audio information. This configuration only occurs before
-     *     the graph is set/started. If unset, a default stream name will be used.
-     * @param headerName The optional name of the header input side packet to
-     *     additionally configure with audio information. This configuration only
-     *     occurs before the graph is set/started. If unset, a default header name
-     *     will be used.
-     */
-    configureAudio(numChannels: number, numSamples: number, sampleRate: number, streamName?: string, headerName?: string): 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 streamName The name of the MediaPipe graph stream to add the audio
-     *     data to.
-     * @param timestamp The timestamp of the current frame, in ms.
-     */
-    addAudioToStream(audioData: Float32Array, streamName: string, timestamp: number): void;
-    /**
-     * Takes the raw data from a JS audio capture array, and sends it to C++ to be
-     * processed, shaping the audioData array into an audio matrix according to
-     * the numChannels and numSamples parameters.
-     * @param audioData An array of raw audio capture data, like
-     *     from a call to getChannelData on an AudioBuffer.
-     * @param numChannels The number of audio channels this data represents. If 0
-     *     is passed, then the value will be taken from the last call to
-     *     configureAudio.
-     * @param numSamples The number of audio samples captured in this data packet.
-     *     If 0 is passed, then the value will be taken from the last call to
-     *     configureAudio.
-     * @param streamName The name of the MediaPipe graph stream to add the audio
-     *     data to.
-     * @param timestamp The timestamp of the current frame, in ms.
-     */
-    addAudioToStreamWithShape(audioData: Float32Array, numChannels: number, numSamples: number, streamName: string, 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.
+     * Recognized hand gestures of detected hands. Note that the index of the
+     * gesture is always -1, because the raw indices from multiple gesture
+     * classifiers cannot consolidate to a meaningful index.
      */
-    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;
-    /**
-     * Attaches an audio packet listener to the specified output_stream, to be
-     * given a Float32Array as output.
-     * @param outputStreamName The name of the graph output stream to grab audio
-     *     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. If the
-     *     audio 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).
-     */
-    attachAudioListener(outputStreamName: string, callbackFcn: (data: Float32Array) => void, makeDeepCopy?: 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;
-}
-
-/** An implementation of the GraphRunner that supports image operations */
-declare class GraphRunnerImageLib extends GraphRunnerImageLibType {
+    gestures: Category[][];
 }
 
-declare const GraphRunnerImageLibType: (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, streamName?: string | undefined, headerName?: string | undefined): 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, streamName: string, timestamp: number): void;
-    addAudioToStreamWithShape(audioData: Float32Array, numChannels: number, numSamples: number, streamName: string, 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;
-    attachAudioListener(outputStreamName: string, callbackFcn: (data: Float32Array) => void, makeDeepCopy?: boolean | undefined): 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, streamName?: string | undefined, headerName?: string | undefined): 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_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; /**
-    * Creates a new instance of a Mediapipe Task. Determines if SIMD is
-    * supported and loads the relevant WASM binary.
-    * @return A fully instantiated instance of `T`.
-    */
-    addAudioToStream(audioData: Float32Array, streamName: string, timestamp: number): void;
-    addAudioToStreamWithShape(audioData: Float32Array, numChannels: number, numSamples: number, streamName: string, 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;
-    attachAudioListener(outputStreamName: string, callbackFcn: (data: Float32Array) => void, makeDeepCopy?: boolean | undefined): void;
-    finishProcessing(): void;
-}) & typeof GraphRunner;
-
 /** Performs hand landmarks detection on images. */
-export declare class HandLandmarker extends VisionTaskRunner<HandLandmarkerResult> {
-    private landmarks;
-    private worldLandmarks;
-    private handednesses;
-    private readonly options;
-    private readonly handLandmarksDetectorGraphOptions;
-    private readonly handDetectorGraphOptions;
+export declare class HandLandmarker extends VisionTaskRunner {
     /**
      * Initializes the Wasm runtime and creates a new `HandLandmarker` from the
      * provided options.
@@ -1185,9 +423,7 @@ export declare class HandLandmarker extends VisionTaskRunner<HandLandmarkerResul
      * @param modelAssetPath The path to the model asset.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<HandLandmarker>;
-    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
-    protected get baseOptions(): BaseOptions_2;
-    protected set baseOptions(proto: BaseOptions_2);
+    private constructor();
     /**
      * Sets new options for this `HandLandmarker`.
      *
@@ -1204,9 +440,11 @@ export declare class HandLandmarker extends VisionTaskRunner<HandLandmarkerResul
      * HandLandmarker is created with running mode `image`.
      *
      * @param image An image to process.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The detected hand landmarks.
      */
-    detect(image: ImageSource): HandLandmarkerResult;
+    detect(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): HandLandmarkerResult;
     /**
      * Performs hand landmarks detection on the provided video frame and waits
      * synchronously for the response. Only use this method when the
@@ -1214,24 +452,11 @@ export declare class HandLandmarker extends VisionTaskRunner<HandLandmarkerResul
      *
      * @param videoFrame A video frame to process.
      * @param timestamp The timestamp of the current frame, in ms.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The detected hand landmarks.
      */
-    detectForVideo(videoFrame: ImageSource, timestamp: number): HandLandmarkerResult;
-    /** Runs the hand landmarker graph and blocks on the response. */
-    protected process(imageSource: ImageSource, timestamp: number): HandLandmarkerResult;
-    /** 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 world landmark, and adds it to our worldLandmarks
-     * list.
-     */
-    private adddJsWorldLandmarks;
-    /** Updates the MediaPipe graph configuration. */
-    private refreshGraph;
+    detectForVideo(videoFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): HandLandmarkerResult;
 }
 
 /** Options to configure the MediaPipe HandLandmarker Task */
@@ -1271,9 +496,7 @@ export declare interface HandLandmarkerResult {
 }
 
 /** Performs classification on images. */
-export declare class ImageClassifier extends VisionTaskRunner<ImageClassifierResult> {
-    private classificationResult;
-    private readonly options;
+export declare class ImageClassifier extends VisionTaskRunner {
     /**
      * Initializes the Wasm runtime and creates a new image classifier from the
      * provided options.
@@ -1300,9 +523,7 @@ export declare class ImageClassifier extends VisionTaskRunner<ImageClassifierRes
      * @param modelAssetPath The path to the model asset.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<ImageClassifier>;
-    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
-    protected get baseOptions(): BaseOptions_2;
-    protected set baseOptions(proto: BaseOptions_2);
+    private constructor();
     /**
      * Sets new options for the image classifier.
      *
@@ -1319,9 +540,11 @@ export declare class ImageClassifier extends VisionTaskRunner<ImageClassifierRes
      * ImageClassifier is created with running mode `image`.
      *
      * @param image An image to process.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The classification result of the image
      */
-    classify(image: ImageSource): ImageClassifierResult;
+    classify(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): ImageClassifierResult;
     /**
      * Performs image classification on the provided video frame and waits
      * synchronously for the response. Only use this method when the
@@ -1329,13 +552,11 @@ export declare class ImageClassifier extends VisionTaskRunner<ImageClassifierRes
      *
      * @param videoFrame A video frame to process.
      * @param timestamp The timestamp of the current frame, in ms.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The classification result of the image
      */
-    classifyForVideo(videoFrame: ImageSource, timestamp: number): ImageClassifierResult;
-    /** Runs the image classification graph and blocks on the response. */
-    protected process(imageSource: ImageSource, timestamp: number): ImageClassifierResult;
-    /** Updates the MediaPipe graph configuration. */
-    private refreshGraph;
+    classifyForVideo(videoFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): ImageClassifierResult;
 }
 
 /** Options to configure the MediaPipe Image Classifier Task. */
@@ -1359,9 +580,7 @@ export declare interface ImageClassifierResult {
 }
 
 /** Performs embedding extraction on images. */
-export declare class ImageEmbedder extends VisionTaskRunner<ImageEmbedderResult> {
-    private readonly options;
-    private embeddings;
+export declare class ImageEmbedder extends VisionTaskRunner {
     /**
      * Initializes the Wasm runtime and creates a new image embedder from the
      * provided options.
@@ -1388,9 +607,7 @@ export declare class ImageEmbedder extends VisionTaskRunner<ImageEmbedderResult>
      * @param modelAssetPath The path to the TFLite model.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<ImageEmbedder>;
-    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
-    protected get baseOptions(): BaseOptions_2;
-    protected set baseOptions(proto: BaseOptions_2);
+    private constructor();
     /**
      * Sets new options for the image embedder.
      *
@@ -1407,9 +624,11 @@ export declare class ImageEmbedder extends VisionTaskRunner<ImageEmbedderResult>
      * ImageEmbedder is created with running mode `image`.
      *
      * @param image The image to process.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The classification result of the image
      */
-    embed(image: ImageSource): ImageEmbedderResult;
+    embed(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): ImageEmbedderResult;
     /**
      * Performs embedding extraction on the provided video frame and waits
      * synchronously for the response. Only use this method when the
@@ -1417,9 +636,11 @@ export declare class ImageEmbedder extends VisionTaskRunner<ImageEmbedderResult>
      *
      * @param imageFrame The image frame to process.
      * @param timestamp The timestamp of the current frame, in ms.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The classification result of the image
      */
-    embedForVideo(imageFrame: ImageSource, timestamp: number): ImageEmbedderResult;
+    embedForVideo(imageFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): ImageEmbedderResult;
     /**
      * Utility function to compute cosine similarity[1] between two `Embedding`
      * objects.
@@ -1430,15 +651,6 @@ export declare class ImageEmbedder extends VisionTaskRunner<ImageEmbedderResult>
      *     different sizes, or have an L2-norm of 0.
      */
     static cosineSimilarity(u: Embedding, v: Embedding): number;
-    /** Runs the embedding extraction and blocks on the response. */
-    protected process(image: ImageSource, timestamp: number): ImageEmbedderResult;
-    /**
-     * Internal function for converting raw data into an embedding, and setting it
-     * as our embeddings result.
-     */
-    private addJsImageEmdedding;
-    /** Updates the MediaPipe graph configuration. */
-    private refreshGraph;
 }
 
 /** Options for configuring a MediaPipe Image Embedder task. */
@@ -1464,259 +676,40 @@ export declare interface ImageEmbedderResult {
 }
 
 /**
- * Valid types of image sources which we can run our GraphRunner over.
+ * Options for image processing.
+ *
+ * If both region-or-interest and rotation are specified, the crop around the
+ * region-of-interest is extracted first, then the specified rotation is applied
+ * to the crop.
  */
-export declare type ImageSource = HTMLCanvasElement | HTMLVideoElement | HTMLImageElement | ImageData | ImageBitmap;
-
-declare class InferenceCalculatorOptions extends jspb.Message {
-    hasModelPath(): boolean;
-    clearModelPath(): void;
-    getModelPath(): string | undefined;
-    setModelPath(value: string): void;
-
-    hasUseGpu(): boolean;
-    clearUseGpu(): void;
-    getUseGpu(): boolean | undefined;
-    setUseGpu(value: boolean): void;
-
-    hasUseNnapi(): boolean;
-    clearUseNnapi(): void;
-    getUseNnapi(): boolean | undefined;
-    setUseNnapi(value: boolean): void;
-
-    hasCpuNumThread(): boolean;
-    clearCpuNumThread(): void;
-    getCpuNumThread(): number | undefined;
-    setCpuNumThread(value: number): void;
-
-    hasDelegate(): boolean;
-    clearDelegate(): void;
-    getDelegate(): InferenceCalculatorOptions.Delegate | undefined;
-    setDelegate(value?: InferenceCalculatorOptions.Delegate): void;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): InferenceCalculatorOptions.AsObject;
-    static toObject(includeInstance: boolean, msg: InferenceCalculatorOptions): InferenceCalculatorOptions.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: InferenceCalculatorOptions, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): InferenceCalculatorOptions;
-    static deserializeBinaryFromReader(message: InferenceCalculatorOptions, reader: jspb.BinaryReader): InferenceCalculatorOptions;
+declare interface ImageProcessingOptions {
+    /**
+     * The optional region-of-interest to crop from the image. If not specified,
+     * the full image is used.
+     *
+     * Coordinates must be in [0,1] with 'left' < 'right' and 'top' < bottom.
+     */
+    regionOfInterest?: RectF;
+    /**
+     * The rotation to apply to the image (or cropped region-of-interest), in
+     * degrees clockwise.
+     *
+     * The rotation must be a multiple (positive or negative) of 90°.
+     */
+    rotationDegrees?: number;
 }
 
-declare namespace InferenceCalculatorOptions {
-    type AsObject = {
-        modelPath?: string,
-        useGpu?: boolean,
-        useNnapi?: boolean,
-        cpuNumThread?: number,
-        delegate?: InferenceCalculatorOptions.Delegate.AsObject,
-    }
-
-    class Delegate extends jspb.Message {
-        hasTflite(): boolean;
-        clearTflite(): void;
-        getTflite(): InferenceCalculatorOptions.Delegate.TfLite | undefined;
-        setTflite(value?: InferenceCalculatorOptions.Delegate.TfLite): void;
-
-        hasGpu(): boolean;
-        clearGpu(): void;
-        getGpu(): InferenceCalculatorOptions.Delegate.Gpu | undefined;
-        setGpu(value?: InferenceCalculatorOptions.Delegate.Gpu): void;
-
-        hasNnapi(): boolean;
-        clearNnapi(): void;
-        getNnapi(): InferenceCalculatorOptions.Delegate.Nnapi | undefined;
-        setNnapi(value?: InferenceCalculatorOptions.Delegate.Nnapi): void;
-
-        hasXnnpack(): boolean;
-        clearXnnpack(): void;
-        getXnnpack(): InferenceCalculatorOptions.Delegate.Xnnpack | undefined;
-        setXnnpack(value?: InferenceCalculatorOptions.Delegate.Xnnpack): void;
-
-        getDelegateCase(): Delegate.DelegateCase;
-        serializeBinary(): Uint8Array;
-        toObject(includeInstance?: boolean): Delegate.AsObject;
-        static toObject(includeInstance: boolean, msg: Delegate): Delegate.AsObject;
-        static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-        static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-        static serializeBinaryToWriter(message: Delegate, writer: jspb.BinaryWriter): void;
-        static deserializeBinary(bytes: Uint8Array): Delegate;
-        static deserializeBinaryFromReader(message: Delegate, reader: jspb.BinaryReader): Delegate;
-    }
-
-    namespace Delegate {
-        type AsObject = {
-            tflite?: InferenceCalculatorOptions.Delegate.TfLite.AsObject,
-            gpu?: InferenceCalculatorOptions.Delegate.Gpu.AsObject,
-            nnapi?: InferenceCalculatorOptions.Delegate.Nnapi.AsObject,
-            xnnpack?: InferenceCalculatorOptions.Delegate.Xnnpack.AsObject,
-        }
-
-        class TfLite extends jspb.Message {
-            serializeBinary(): Uint8Array;
-            toObject(includeInstance?: boolean): TfLite.AsObject;
-            static toObject(includeInstance: boolean, msg: TfLite): TfLite.AsObject;
-            static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-            static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-            static serializeBinaryToWriter(message: TfLite, writer: jspb.BinaryWriter): void;
-            static deserializeBinary(bytes: Uint8Array): TfLite;
-            static deserializeBinaryFromReader(message: TfLite, reader: jspb.BinaryReader): TfLite;
-        }
-
-        namespace TfLite {
-            type AsObject = {
-            }
-        }
-
-        class Gpu extends jspb.Message {
-            hasUseAdvancedGpuApi(): boolean;
-            clearUseAdvancedGpuApi(): void;
-            getUseAdvancedGpuApi(): boolean | undefined;
-            setUseAdvancedGpuApi(value: boolean): void;
-
-            hasApi(): boolean;
-            clearApi(): void;
-            getApi(): InferenceCalculatorOptions.Delegate.Gpu.ApiMap[keyof InferenceCalculatorOptions.Delegate.Gpu.ApiMap] | undefined;
-            setApi(value: InferenceCalculatorOptions.Delegate.Gpu.ApiMap[keyof InferenceCalculatorOptions.Delegate.Gpu.ApiMap]): void;
-
-            hasAllowPrecisionLoss(): boolean;
-            clearAllowPrecisionLoss(): void;
-            getAllowPrecisionLoss(): boolean | undefined;
-            setAllowPrecisionLoss(value: boolean): void;
-
-            hasCachedKernelPath(): boolean;
-            clearCachedKernelPath(): void;
-            getCachedKernelPath(): string | undefined;
-            setCachedKernelPath(value: string): void;
-
-            hasSerializedModelDir(): boolean;
-            clearSerializedModelDir(): void;
-            getSerializedModelDir(): string | undefined;
-            setSerializedModelDir(value: string): void;
-
-            hasModelToken(): boolean;
-            clearModelToken(): void;
-            getModelToken(): string | undefined;
-            setModelToken(value: string): void;
-
-            hasUsage(): boolean;
-            clearUsage(): void;
-            getUsage(): InferenceCalculatorOptions.Delegate.Gpu.InferenceUsageMap[keyof InferenceCalculatorOptions.Delegate.Gpu.InferenceUsageMap] | undefined;
-            setUsage(value: InferenceCalculatorOptions.Delegate.Gpu.InferenceUsageMap[keyof InferenceCalculatorOptions.Delegate.Gpu.InferenceUsageMap]): void;
-
-            serializeBinary(): Uint8Array;
-            toObject(includeInstance?: boolean): Gpu.AsObject;
-            static toObject(includeInstance: boolean, msg: Gpu): Gpu.AsObject;
-            static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-            static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-            static serializeBinaryToWriter(message: Gpu, writer: jspb.BinaryWriter): void;
-            static deserializeBinary(bytes: Uint8Array): Gpu;
-            static deserializeBinaryFromReader(message: Gpu, reader: jspb.BinaryReader): Gpu;
-        }
-
-        namespace Gpu {
-            type AsObject = {
-                useAdvancedGpuApi?: boolean,
-                api?: InferenceCalculatorOptions.Delegate.Gpu.ApiMap[keyof InferenceCalculatorOptions.Delegate.Gpu.ApiMap],
-                allowPrecisionLoss?: boolean,
-                cachedKernelPath?: string,
-                serializedModelDir?: string,
-                modelToken?: string,
-                usage?: InferenceCalculatorOptions.Delegate.Gpu.InferenceUsageMap[keyof InferenceCalculatorOptions.Delegate.Gpu.InferenceUsageMap],
-            }
-
-            interface ApiMap {
-                ANY: 0;
-                OPENGL: 1;
-                OPENCL: 2;
-            }
-
-            const Api: ApiMap;
-
-            interface InferenceUsageMap {
-                UNSPECIFIED: 0;
-                FAST_SINGLE_ANSWER: 1;
-                SUSTAINED_SPEED: 2;
-            }
-
-            const InferenceUsage: InferenceUsageMap;
-        }
-
-        class Nnapi extends jspb.Message {
-            hasCacheDir(): boolean;
-            clearCacheDir(): void;
-            getCacheDir(): string | undefined;
-            setCacheDir(value: string): void;
-
-            hasModelToken(): boolean;
-            clearModelToken(): void;
-            getModelToken(): string | undefined;
-            setModelToken(value: string): void;
-
-            hasAcceleratorName(): boolean;
-            clearAcceleratorName(): void;
-            getAcceleratorName(): string | undefined;
-            setAcceleratorName(value: string): void;
-
-            serializeBinary(): Uint8Array;
-            toObject(includeInstance?: boolean): Nnapi.AsObject;
-            static toObject(includeInstance: boolean, msg: Nnapi): Nnapi.AsObject;
-            static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-            static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-            static serializeBinaryToWriter(message: Nnapi, writer: jspb.BinaryWriter): void;
-            static deserializeBinary(bytes: Uint8Array): Nnapi;
-            static deserializeBinaryFromReader(message: Nnapi, reader: jspb.BinaryReader): Nnapi;
-        }
-
-        namespace Nnapi {
-            type AsObject = {
-                cacheDir?: string,
-                modelToken?: string,
-                acceleratorName?: string,
-            }
-        }
-
-        class Xnnpack extends jspb.Message {
-            hasNumThreads(): boolean;
-            clearNumThreads(): void;
-            getNumThreads(): number | undefined;
-            setNumThreads(value: number): void;
-
-            serializeBinary(): Uint8Array;
-            toObject(includeInstance?: boolean): Xnnpack.AsObject;
-            static toObject(includeInstance: boolean, msg: Xnnpack): Xnnpack.AsObject;
-            static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-            static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-            static serializeBinaryToWriter(message: Xnnpack, writer: jspb.BinaryWriter): void;
-            static deserializeBinary(bytes: Uint8Array): Xnnpack;
-            static deserializeBinaryFromReader(message: Xnnpack, reader: jspb.BinaryReader): Xnnpack;
-        }
-
-        namespace Xnnpack {
-            type AsObject = {
-                numThreads?: number,
-            }
-        }
-
-        enum DelegateCase {
-            DELEGATE_NOT_SET = 0,
-            TFLITE = 1,
-            GPU = 2,
-            NNAPI = 3,
-            XNNPACK = 4,
-        }
-    }
-
-    const ext: jspb.ExtensionFieldInfo<InferenceCalculatorOptions>;
-}
+/**
+ * Valid types of image sources which we can run our GraphRunner over.
+ */
+export declare type ImageSource = HTMLCanvasElement | HTMLVideoElement | HTMLImageElement | ImageData | ImageBitmap;
 
 /**
  * Landmark represents a point in 3D space with x, y, z coordinates. The
  * landmark coordinates are in meters. z represents the landmark depth,
  * and the smaller the value the closer the world landmark is to the camera.
  */
-declare interface Landmark {
+export declare interface Landmark {
     /** The x coordinates of the landmark. */
     x: number;
     /** The y coordinates of the landmark. */
@@ -1725,26 +718,6 @@ declare interface Landmark {
     z: number;
 }
 
-declare namespace mediapipe_calculators_tensor_inference_calculator_pb {
-    export {
-        InferenceCalculatorOptions
-    }
-}
-
-declare namespace mediapipe_tasks_cc_core_proto_acceleration_pb {
-    export {
-        Acceleration
-    }
-}
-
-declare namespace mediapipe_tasks_cc_core_proto_external_file_pb {
-    export {
-        ExternalFile,
-        FileDescriptorMeta,
-        FilePointerMeta
-    }
-}
-
 /**
  * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
  *
@@ -1767,7 +740,7 @@ declare namespace mediapipe_tasks_cc_core_proto_external_file_pb {
  * closer the landmark is to the camera. The magnitude of z uses roughly the
  * same scale as x.
  */
-declare interface NormalizedLandmark {
+export declare interface NormalizedLandmark {
     /** The x coordinates of the normalized landmark. */
     x: number;
     /** The y coordinates of the normalized landmark. */
@@ -1777,9 +750,7 @@ declare interface NormalizedLandmark {
 }
 
 /** Performs object detection on images. */
-export declare class ObjectDetector extends VisionTaskRunner<Detection[]> {
-    private detections;
-    private readonly options;
+export declare class ObjectDetector extends VisionTaskRunner {
     /**
      * Initializes the Wasm runtime and creates a new object detector from the
      * provided options.
@@ -1806,9 +777,7 @@ export declare class ObjectDetector extends VisionTaskRunner<Detection[]> {
      * @param modelAssetPath The path to the model asset.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<ObjectDetector>;
-    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
-    protected get baseOptions(): BaseOptions_2;
-    protected set baseOptions(proto: BaseOptions_2);
+    private constructor();
     /**
      * Sets new options for the object detector.
      *
@@ -1825,77 +794,62 @@ export declare class ObjectDetector extends VisionTaskRunner<Detection[]> {
      * ObjectDetector is created with running mode `image`.
      *
      * @param image An image to process.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The list of detected objects
      */
-    detect(image: ImageSource): Detection[];
+    detect(image: ImageSource, imageProcessingOptions?: ImageProcessingOptions): Detection[];
     /**
-     * Performs object detection on the provided vidoe frame and waits
+     * Performs object detection on the provided video frame and waits
      * synchronously for the response. Only use this method when the
      * ObjectDetector is created with running mode `video`.
      *
      * @param videoFrame A video frame to process.
      * @param timestamp The timestamp of the current frame, in ms.
+     * @param imageProcessingOptions the `ImageProcessingOptions` specifying how
+     *    to process the input image before running inference.
      * @return The list of detected objects
      */
-    detectForVideo(videoFrame: ImageSource, timestamp: number): Detection[];
-    /** Runs the object detector graph and blocks on the response. */
-    protected process(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;
+    detectForVideo(videoFrame: ImageSource, timestamp: number, imageProcessingOptions?: ImageProcessingOptions): Detection[];
 }
 
 /** Options to configure the MediaPipe Object Detector Task */
 export declare interface ObjectDetectorOptions extends VisionTaskOptions, ClassifierOptions {
 }
 
+/**
+ * Defines a rectangle, used e.g. as part of detection results or as input
+ * region-of-interest.
+ *
+ * The coordinates are normalized with respect to the image dimensions, i.e.
+ * generally in [0,1] but they may exceed these bounds if describing a region
+ * overlapping the image. The origin is on the top-left corner of the image.
+ */
+declare interface RectF {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+
 /**
  * The two running modes of a vision task.
  * 1) The image mode for processing single image inputs.
  * 2) The video mode for processing decoded frames of a video.
  */
-declare type RunningMode = 'image' | 'video';
+declare type RunningMode = "IMAGE" | "VIDEO";
 
 /** Base class for all MediaPipe Tasks. */
-declare abstract class TaskRunner<O extends TaskRunnerOptions> {
-    protected abstract baseOptions: BaseOptions_2;
-    protected graphRunner: GraphRunnerImageLib;
-    private processingErrors;
-    /**
-     * Creates a new instance of a Mediapipe Task. Determines if SIMD is
-     * supported and loads the relevant WASM binary.
-     * @return A fully instantiated instance of `T`.
-     */
-    protected static createInstance<T extends TaskRunner<O>, O extends TaskRunnerOptions>(type: WasmMediaPipeConstructor<T>, initializeCanvas: boolean, fileset: WasmFileset, options: O): Promise<T>;
-    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
-    /** Configures the shared options of a MediaPipe Task. */
-    setOptions(options: O): Promise<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.
-     */
-    protected 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.
-     */
-    protected finishProcessing(): void;
-    /** Throws the error from the error listener if an error was raised. */
-    private handleErrors;
+declare abstract class TaskRunner {
+    protected constructor();
+    /** Configures the task with custom options. */
+    abstract setOptions(options: TaskRunnerOptions): Promise<void>;
 }
 
 /** Options to configure MediaPipe Tasks in general. */
 declare interface TaskRunnerOptions {
     /** Options to configure the loading of the model assets. */
-    baseOptions?: BaseOptions;
+    baseOptions?: BaseOptions_2;
 }
 
 /** The options for configuring a MediaPipe vision task. */
@@ -1910,15 +864,10 @@ declare interface VisionTaskOptions extends TaskRunnerOptions {
 }
 
 /** Base class for all MediaPipe Vision Tasks. */
-declare abstract class VisionTaskRunner<T> extends TaskRunner<VisionTaskOptions> {
+declare abstract class VisionTaskRunner extends TaskRunner {
+    protected constructor();
     /** Configures the shared options of a vision task. */
-    setOptions(options: VisionTaskOptions): Promise<void>;
-    /** Sends an image packet to the graph and awaits results. */
-    protected abstract process(input: ImageSource, timestamp: number): T;
-    /** Sends a single image to the graph and awaits results. */
-    protected processImageData(image: ImageSource): T;
-    /** Sends a single video frame to the graph and awaits results. */
-    protected processVideoData(imageFrame: ImageSource, timestamp: number): T;
+    applyOptions(options: VisionTaskOptions): Promise<void>;
 }
 
 /**
@@ -1944,75 +893,4 @@ declare interface WasmFileset {
     wasmBinaryPath: string;
 }
 
-/**
- * Internal type of constructors used for initializing GraphRunner and
- * subclasses.
- */
-declare type WasmMediaPipeConstructor<LibType> = (new (module: WasmModule, canvas?: HTMLCanvasElement | OffscreenCanvas | null) => LibType);
-
-/**
- * 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;
-    _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;
-    _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;
-    _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;
-    _processGl: (frameDataPtr: number) => number;
-}
-
 export { }