import * as tf from '@tensorflow/tfjs';
import { WebGLStateManager } from './webglStateManager';
import type { DenoiserProps, ImgInput, InputOptions, ListenerCalback, ModelInput } from 'types/types';
export declare class Denoiser {
    timesGenerated: number;
    backend?: tf.KernelBackend;
    backendLoaded: boolean;
    usingCustomBackend: boolean;
    props: DenoiserProps;
    directInputTensor?: tf.Tensor3D;
    inputMode: 'imgData' | 'webgl' | 'webgpu' | 'tensor';
    outputMode: 'imgData' | 'webgl' | 'webgpu' | 'tensor' | 'float32';
    flipOutputY: boolean;
    _useTiling: boolean;
    _tilingUserBlocked: boolean;
    tileSize: number;
    private listeners;
    private backendListeners;
    private progressListeners;
    private aborted;
    private unet;
    private tiler?;
    inputTensors: Map<'color' | 'albedo' | 'normal', tf.Tensor3D>;
    inputAlpha?: tf.Tensor3D;
    oldOutputTensor?: tf.Tensor3D;
    webglStateManager?: WebGLStateManager;
    private _gl?;
    device?: GPUDevice;
    warmstart: boolean;
    private weights;
    private activeTensorMap;
    private isDirty;
    canvas?: HTMLCanvasElement;
    outputToCanvas: boolean;
    debugging: boolean;
    profiling: boolean;
    usePassThrough: boolean;
    stats: {
        [key: string]: number | string;
    };
    timers: {
        [key: string]: number;
    };
    constructor(preferedBackend?: string, canvasOrDevice?: HTMLCanvasElement | GPUDevice);
    set weightsPath(path: string);
    get weightsPath(): string;
    set weightsUrl(url: string);
    get weightsUrl(): string;
    get height(): number;
    set height(height: number);
    get width(): number;
    set width(width: number);
    get quality(): 'fast' | 'high' | 'balanced';
    set quality(quality: 'fast' | 'high' | 'balanced');
    get hdr(): boolean;
    set hdr(hdr: boolean);
    get batchSize(): number;
    set batchSize(batchSize: number);
    get srgb(): boolean;
    set srgb(srgb: boolean);
    get dirtyAux(): boolean;
    set dirtyAux(dirtyAux: boolean);
    get backendReady(): boolean;
    set backendReady(isReady: boolean);
    get gl(): WebGL2RenderingContext | undefined;
    set gl(gl: WebGL2RenderingContext);
    get useTiling(): boolean;
    set useTiling(useTiling: boolean);
    set debuggTF(debug: boolean);
    setProp(propName: keyof DenoiserProps, value: any): void;
    build(): Promise<void>;
    execute(colorInput?: ModelInput, albedoInput?: ModelInput, normalInput?: ModelInput): Promise<unknown>;
    private executeModel;
    private handleReturn;
    private handleAbort;
    setInputTensor(name: 'color' | 'albedo' | 'normal', tensor: tf.Tensor3D): void;
    setImage(name: 'color' | 'albedo' | 'normal', imgData: ImgInput, flipY?: boolean): void;
    setInputImage(name: 'color' | 'albedo' | 'normal', imgData: ImgInput, flipY?: boolean): void;
    createImageTensor(input: ImgInput, isNormalMap?: boolean): tf.Tensor3D;
    setInputBuffer(name: 'color' | 'albedo' | 'normal', buffer: GPUBuffer, options?: InputOptions): Promise<void>;
    setInputTexture(name: 'color' | 'albedo' | 'normal', texture: WebGLTexture, options?: InputOptions): Promise<void>;
    setInputData(name: 'color' | 'albedo' | 'normal', data: Float32Array | Uint8Array, options?: InputOptions): void;
    setCanvas(canvas: HTMLCanvasElement): void;
    resetInputs(): void;
    abort(): void;
    dispose(): void;
    private handleProgress;
    onProgress(listener: (progress: number) => void): () => boolean;
    onExecute(listener: ListenerCalback, responseType?: "float32" | "webgl" | "webgpu" | "tensor" | "imgData"): () => boolean;
    onBackendReady(listener: ListenerCalback): () => boolean;
    startTimer(name: string): void;
    stopTimer(name: string): void;
    timed(name: string, fn: () => any): Promise<any>;
    logStats(): void;
}