@mediapipe/tasks-audio 0.1.0-alpha-1670012900 → 0.1.0-alpha-2

package/audio.d.ts

@@ -1,53 +1,5 @@
-/// <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,
-    }
-}
-
 /** Performs audio classification. */
 export declare class AudioClassifier extends AudioTaskRunner<AudioClassifierResult[]> {
-    private classificationResults;
-    private readonly options;
     /**
      * Initializes the Wasm runtime and creates a new audio classifier from the
      * provided options.
@@ -74,8 +26,7 @@ export declare class AudioClassifier extends AudioTaskRunner<AudioClassifierResu
      * @param modelAssetPath The path to the model asset.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<AudioClassifier>;
-    protected get baseOptions(): BaseOptions | undefined;
-    protected set baseOptions(proto: BaseOptions | undefined);
+    private constructor();
     /**
      * Sets new options for the audio classifier.
      *
@@ -98,19 +49,10 @@ export declare class AudioClassifier extends AudioTaskRunner<AudioClassifierResu
      * @return The classification result of the audio datas
      */
     classify(audioData: Float32Array, sampleRate?: number): AudioClassifierResult[];
-    /** Sends an audio package to the graph and returns the classifications. */
-    protected process(audioData: Float32Array, sampleRate: number, timestampMs: number): AudioClassifierResult[];
-    /**
-     * Internal function for converting raw data into classification results, and
-     * adding them to our classfication results list.
-     **/
-    private addJsAudioClassificationResults;
-    /** Updates the MediaPipe graph configuration. */
-    private refreshGraph;
 }
 
 /** Options to configure the MediaPipe Audio Classifier Task */
-export declare interface AudioClassifierOptions extends ClassifierOptions, AudioTaskOptions {
+export declare interface AudioClassifierOptions extends ClassifierOptions, TaskRunnerOptions {
 }
 
 /** Classification results of a model. */
@@ -131,8 +73,6 @@ export declare interface AudioClassifierResult {
 
 /** Performs embedding extraction on audio. */
 export declare class AudioEmbedder extends AudioTaskRunner<AudioEmbedderResult[]> {
-    private embeddingResults;
-    private readonly options;
     /**
      * Initializes the Wasm runtime and creates a new audio embedder from the
      * provided options.
@@ -159,8 +99,7 @@ export declare class AudioEmbedder extends AudioTaskRunner<AudioEmbedderResult[]
      * @param modelAssetPath The path to the TFLite model.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<AudioEmbedder>;
-    protected get baseOptions(): BaseOptions | undefined;
-    protected set baseOptions(proto: BaseOptions | undefined);
+    private constructor();
     /**
      * Sets new options for the audio embedder.
      *
@@ -193,13 +132,10 @@ export declare class AudioEmbedder extends AudioTaskRunner<AudioEmbedderResult[]
      *     different sizes, or have an L2-norm of 0.
      */
     static cosineSimilarity(u: Embedding, v: Embedding): number;
-    protected process(audioData: Float32Array, sampleRate: number, timestampMs: number): AudioEmbedderResult[];
-    /** Updates the MediaPipe graph configuration. */
-    private refreshGraph;
 }
 
 /** Options to configure the MediaPipe Audio Embedder Task */
-export declare interface AudioEmbedderOptions extends EmbedderOptions, AudioTaskOptions {
+export declare interface AudioEmbedderOptions extends EmbedderOptions, TaskRunnerOptions {
 }
 
 /**  Embedding results for a given embedder model. */
@@ -220,18 +156,8 @@ export declare interface AudioEmbedderResult {
     timestampMs?: number;
 }
 
-/** The options for configuring a MediaPipe Audio Task. */
-declare interface AudioTaskOptions {
-    /** Options to configure the loading of the model assets. */
-    baseOptions?: BaseOptions_2;
-}
-
 /** Base class for all MediaPipe Audio Tasks. */
 declare abstract class AudioTaskRunner<T> extends TaskRunner {
-    protected abstract baseOptions?: BaseOptions | undefined;
-    private defaultSampleRate;
-    /** Configures the shared options of an audio task. */
-    setOptions(options: AudioTaskOptions): Promise<void>;
     /**
      * Sets the sample rate for API calls that omit an explicit sample rate.
      * `48000` is used as a default if this method is not called.
@@ -239,44 +165,6 @@ declare abstract class AudioTaskRunner<T> extends TaskRunner {
      * @param sampleRate A sample rate (e.g. `44100`).
      */
     setDefaultSampleRate(sampleRate: number): void;
-    /** Sends an audio packet to the graph and awaits results. */
-    protected abstract process(audioData: Float32Array, sampleRate: number, timestampMs: number): T;
-    /** Sends a single audio clip to the graph and awaits results. */
-    protected processAudioClip(audioData: Float32Array, sampleRate?: number): T;
-}
-
-declare class BaseOptions 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.AsObject;
-    static toObject(includeInstance: boolean, msg: BaseOptions): BaseOptions.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: BaseOptions, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): BaseOptions;
-    static deserializeBinaryFromReader(message: BaseOptions, reader: jspb.BinaryReader): BaseOptions;
-}
-
-declare namespace BaseOptions {
-    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,
-    }
 }
 
 /**
@@ -294,7 +182,7 @@ declare namespace BaseOptions {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/** Options to configure MediaPipe Tasks in general. */
+/** Options to configure MediaPipe model loading and processing. */
 declare interface BaseOptions_2 {
     /**
      * The model path to the model asset file. Only one of `modelAssetPath` or
@@ -307,7 +195,7 @@ declare interface BaseOptions_2 {
      */
     modelAssetBuffer?: Uint8Array | undefined;
     /** Overrides the default backend to use for the provided model. */
-    delegate?: 'cpu' | 'gpu' | undefined;
+    delegate?: "CPU" | "GPU" | undefined;
 }
 
 /**
@@ -485,113 +373,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.
  *
@@ -644,744 +425,17 @@ export declare class FilesetResolver {
     static forVisionTasks(basePath?: string): Promise<WasmFileset>;
 }
 
-/**
- * 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.
-     */
-    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;
-}
-
-/**
- * Valid types of image sources which we can run our GraphRunner over.
- */
-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 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>;
-}
-
-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
-    }
+/** Base class for all MediaPipe Tasks. */
+declare abstract class TaskRunner {
+    protected constructor();
+    /** Configures the task with custom options. */
+    abstract setOptions(options: TaskRunnerOptions): Promise<void>;
 }
 
-/** Base class for all MediaPipe Tasks. */
-declare abstract class TaskRunner extends WasmMediaPipeImageLib {
-    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>(type: WasmMediaPipeConstructor<T>, initializeCanvas: boolean, fileset: WasmFileset): Promise<T>;
-    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
-    /**
-     * 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;
+/** Options to configure MediaPipe Tasks in general. */
+declare interface TaskRunnerOptions {
+    /** Options to configure the loading of the model assets. */
+    baseOptions?: BaseOptions_2;
 }
 
 /**
@@ -1407,177 +461,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);
-
-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, 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;
-    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;
-
-/**
- * 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 { }