@mediapipe/tasks-text 0.1.0-alpha-1669754728 → 0.1.0-alpha-1

package/text.d.ts

@@ -1,5 +1,49 @@
 /// <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.
  *
@@ -15,7 +59,7 @@
  * 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 {
     /**
      * The model path to the model asset file. Only one of `modelAssetPath` or
@@ -31,6 +75,40 @@ declare interface BaseOptions {
     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,
+    }
+}
+
 /**
  * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
  *
@@ -209,6 +287,110 @@ export declare interface Embedding {
 /** 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.
  *
@@ -702,21 +884,398 @@ declare class GraphRunner {
     finishProcessing(): void;
 }
 
+/** An implementation of the GraphRunner that supports image operations */
+declare class GraphRunnerImageLib extends GraphRunnerImageLibType {
+}
+
+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;
+
 /**
  * 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 extends WasmMediaPipeImageLib {
+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>(type: WasmMediaPipeConstructor<T>, initializeCanvas: boolean, fileset: WasmFileset): Promise<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,
@@ -727,19 +1286,25 @@ declare abstract class TaskRunner extends WasmMediaPipeImageLib {
      * @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;
+    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.
      */
-    finishProcessing(): void;
+    protected 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;
+}
+
 /** Performs Natural Language classification. */
-export declare class TextClassifier extends TaskRunner {
+export declare class TextClassifier extends TaskRunner<TextClassifierOptions> {
     private classificationResult;
     private readonly options;
     /**
@@ -768,6 +1333,7 @@ export declare class TextClassifier extends TaskRunner {
      * @param modelAssetPath The path to the model asset.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<TextClassifier>;
+    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
     /**
      * Sets new options for the text classifier.
      *
@@ -778,6 +1344,8 @@ export declare class TextClassifier extends TaskRunner {
      * @param options The options for the text classifier.
      */
     setOptions(options: TextClassifierOptions): Promise<void>;
+    protected get baseOptions(): BaseOptions_2;
+    protected set baseOptions(proto: BaseOptions_2);
     /**
      * Performs Natural Language classification on the provided text and waits
      * synchronously for the response.
@@ -791,7 +1359,7 @@ export declare class TextClassifier extends TaskRunner {
 }
 
 /** Options to configure the MediaPipe Text Classifier Task */
-export declare interface TextClassifierOptions extends ClassifierOptions, TextTaskOptions {
+export declare interface TextClassifierOptions extends ClassifierOptions, TaskRunnerOptions {
 }
 
 /** Classification results of a model. */
@@ -813,7 +1381,7 @@ export declare interface TextClassifierResult {
 /**
  * Performs embedding extraction on text.
  */
-export declare class TextEmbedder extends TaskRunner {
+export declare class TextEmbedder extends TaskRunner<TextEmbedderOptions> {
     private embeddingResult;
     private readonly options;
     /**
@@ -842,6 +1410,7 @@ export declare class TextEmbedder extends TaskRunner {
      * @param modelAssetPath The path to the TFLite model.
      */
     static createFromModelPath(wasmFileset: WasmFileset, modelAssetPath: string): Promise<TextEmbedder>;
+    constructor(wasmModule: WasmModule, glCanvas?: HTMLCanvasElement | OffscreenCanvas | null);
     /**
      * Sets new options for the text embedder.
      *
@@ -852,6 +1421,8 @@ export declare class TextEmbedder extends TaskRunner {
      * @param options The options for the text embedder.
      */
     setOptions(options: TextEmbedderOptions): Promise<void>;
+    protected get baseOptions(): BaseOptions_2;
+    protected set baseOptions(proto: BaseOptions_2);
     /**
      * Performs embeding extraction on the provided text and waits synchronously
      * for the response.
@@ -875,7 +1446,7 @@ export declare class TextEmbedder extends TaskRunner {
 }
 
 /** Options to configure the MediaPipe Text Embedder Task */
-export declare interface TextEmbedderOptions extends EmbedderOptions, TextTaskOptions {
+export declare interface TextEmbedderOptions extends EmbedderOptions, TaskRunnerOptions {
 }
 
 /**  Embedding results for a given embedder model. */
@@ -896,12 +1467,6 @@ export declare interface TextEmbedderResult {
     timestampMs?: number;
 }
 
-/** The options for configuring a MediaPipe Text task. */
-declare interface TextTaskOptions {
-    /** Options to configure the loading of the model assets. */
-    baseOptions?: BaseOptions;
-}
-
 /**
  * Copyright 2022 The MediaPipe Authors. All Rights Reserved.
  *
@@ -931,108 +1496,6 @@ declare interface WasmFileset {
  */
 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.