import { Tracker } from "../core/tracker/tracker.js";
import { InputLoader } from "../core/input-loader.js";
import { FeatureManager } from "../core/features/feature-manager.js";
import { DetectorLite } from "../core/detector/detector-lite.js";
export interface ControllerOptions {
    inputWidth: number;
    inputHeight: number;
    onUpdate?: ((data: any) => void) | null;
    debugMode?: boolean;
    maxTrack?: number;
    warmupTolerance?: number | null;
    missTolerance?: number | null;
    filterMinCF?: number | null;
    filterBeta?: number | null;
    worker?: any;
}
declare class Controller {
    inputWidth: number;
    inputHeight: number;
    maxTrack: number;
    inputLoader: InputLoader;
    markerDimensions: any[] | null;
    onUpdate: ((data: any) => void) | null;
    debugMode: boolean;
    processingVideo: boolean;
    interestedTargetIndex: number;
    trackingStates: any[];
    worker: any;
    projectionTransform: number[][];
    projectionMatrix: number[];
    tracker: Tracker | null;
    matchingDataList: any;
    workerMatchDone: ((data: any) => void) | null;
    workerTrackDone: ((data: any) => void) | null;
    workerFullTrackDone: ((data: any) => void) | null;
    mainThreadMatcher: any;
    mainThreadEstimator: any;
    featureManager: FeatureManager;
    fullDetector: DetectorLite | null;
    constructor({ inputWidth, inputHeight, onUpdate, debugMode, maxTrack, warmupTolerance, missTolerance, filterMinCF, filterBeta, worker, }: ControllerOptions);
    _setupWorkerListener(): void;
    _ensureWorker(): void;
    addImageTargets(fileURLs: string | string[]): Promise<{
        dimensions: any[];
        matchingDataList: any[];
        trackingDataList: any[];
    }>;
    addImageTargetsFromBuffers(buffers: ArrayBuffer[]): {
        dimensions: any[];
        matchingDataList: any[];
        trackingDataList: any[];
    };
    addImageTargetsFromBuffer(buffer: ArrayBuffer): {
        dimensions: any[];
        matchingDataList: any[];
        trackingDataList: any[];
    };
    dispose(): void;
    dummyRun(input: any): void;
    getProjectionMatrix(): number[];
    getRotatedZ90Matrix(m: number[]): number[];
    getWorldMatrix(modelViewTransform: number[][], targetIndex: number): number[];
    _detectAndMatch(inputData: any, targetIndexes: number[]): Promise<{
        targetIndex: any;
        modelViewTransform: any;
        screenCoords: any;
        worldCoords: any;
        featurePoints: any;
    }>;
    _trackAndUpdate(inputData: any, lastModelViewTransform: number[][], targetIndex: number): Promise<{
        modelViewTransform: null;
        screenCoords: never[];
        reliabilities: never[];
        stabilities: never[];
        deformedMesh: null;
        octaveIndex?: undefined;
    } | {
        modelViewTransform: null;
        screenCoords: any[];
        reliabilities: number[];
        stabilities: number[];
        deformedMesh?: undefined;
        octaveIndex?: undefined;
    } | {
        modelViewTransform: any;
        screenCoords: any[];
        reliabilities: number[];
        stabilities: number[];
        deformedMesh: any;
        octaveIndex: any;
    }>;
    processVideo(input: any): void;
    stopProcessVideo(): void;
    detect(input: any): Promise<{
        featurePoints: any[];
        debugExtra: {};
    }>;
    match(featurePoints: any, targetIndex: number): Promise<{
        targetIndex: any;
        modelViewTransform: any;
        screenCoords: any;
        worldCoords: any;
        debugExtra: any;
    }>;
    track(input: any, modelViewTransform: number[][], targetIndex: number): Promise<{
        worldCoords: never[];
        screenCoords: never[];
        reliabilities: never[];
        debugExtra: {};
        indices?: undefined;
        octaveIndex?: undefined;
        deformedMesh?: undefined;
    } | {
        worldCoords: {
            x: number;
            y: number;
            z: number;
        }[];
        screenCoords: {
            x: number;
            y: number;
        }[];
        reliabilities: number[];
        indices: number[];
        octaveIndex: any;
        deformedMesh: {
            vertices: Float32Array<ArrayBuffer>;
            triangles: any;
        } | null;
        debugExtra: {};
    }>;
    trackUpdate(modelViewTransform: number[][], trackFeatures: any): Promise<any>;
    _workerMatch(featurePoints: any, targetIndexes: number[], inputData?: any, expectedScale?: number): Promise<any>;
    _workerTrack(inputData: any, lastModelViewTransform: number[][], targetIndex: number): Promise<any>;
    _matchOnMainThread(featurePoints: any, targetIndexes: number[], expectedScale?: number): Promise<{
        targetIndex: number;
        modelViewTransform: any;
        screenCoords: any;
        worldCoords: any;
        debugExtra: any;
    }>;
    _workerTrackUpdate(modelViewTransform: number[][], trackingFeatures: any): Promise<any>;
    _trackUpdateOnMainThread(modelViewTransform: number[][], trackingFeatures: any): Promise<any>;
    _glModelViewMatrix(modelViewTransform: number[][], targetIndex: number): number[];
    _glProjectionMatrix({ projectionTransform, width, height, near, far }: any): number[];
}
export { Controller };