/**
 * TapTapp AR - Easy Tracking Configuration
 *
 * Simple API for configuring image target tracking with minimal setup.
 * Based on the reliable configuration from reliability-test.html.
 *
 * @example
 * ```typescript
 * import { createTracker } from 'taptapp-ar';
 *
 * const tracker = await createTracker({
 *   targetSrc: './my-target.png',
 *   container: document.getElementById('ar-container')!,
 *   overlay: document.getElementById('overlay')!,
 *   callbacks: {
 *     onFound: () => console.log('Target found!'),
 *     onLost: () => console.log('Target lost'),
 *     onUpdate: (data) => console.log('Update:', data)
 *   }
 * });
 *
 * // Start tracking from camera
 * tracker.startCamera();
 *
 * // Or track from a video/canvas element
 * tracker.startVideo(videoElement);
 *
 * // Stop tracking
 * tracker.stop();
 * ```
 */
import { BioInspiredController } from './bio-inspired-controller.js';
/**
 * Tracking update data passed to onUpdate callback
 */
export interface TrackingUpdate {
    /** Whether the target is currently being tracked */
    isTracking: boolean;
    /** 4x4 world transformation matrix (column-major, for WebGL/Three.js) */
    worldMatrix: number[] | null;
    /** 3x4 model-view transform matrix */
    modelViewTransform: number[][] | null;
    /** Screen coordinates of tracked feature points */
    screenCoords: Array<{
        x: number;
        y: number;
        id: number;
    }>;
    /** Reliability scores (0-1) for each tracked point */
    reliabilities: number[];
    /** Stability scores (0-1) for each tracked point */
    stabilities: number[];
    /** Average reliability across all points */
    avgReliability: number;
    /** Average stability across all points */
    avgStability: number;
    /** Reference to the controller for advanced usage */
    controller: BioInspiredController;
    /** Index of the tracked target (for multi-target tracking) */
    targetIndex: number;
    /** Target dimensions [width, height] */
    targetDimensions: [number, number];
}
/**
 * Tracking event callbacks
 */
export interface TrackingCallbacks {
    /**
     * Called when the target is first detected
     * @param data Initial tracking data
     */
    onFound?: (data: TrackingUpdate) => void;
    /**
     * Called when tracking is lost
     * @param data Last known tracking data
     */
    onLost?: (data: TrackingUpdate) => void;
    /**
     * Called on every frame update while tracking
     * @param data Current tracking data
     */
    onUpdate?: (data: TrackingUpdate) => void;
    /**
     * Called during target compilation
     * @param progress Progress percentage (0-100)
     */
    onCompileProgress?: (progress: number) => void;
}
/**
 * Configuration options for the tracker
 */
export interface TrackerConfig {
    /**
     * Source of the target image to track.
     * Can be a URL string, HTMLImageElement, ImageData, or ArrayBuffer (pre-compiled .taar)
     */
    targetSrc: string | HTMLImageElement | ImageData | ArrayBuffer;
    /**
     * Container element for the video/canvas display
     */
    container: HTMLElement;
    /**
     * Optional overlay element to position over the tracked target
     */
    overlay?: HTMLElement;
    /**
     * Tracking event callbacks
     */
    callbacks?: TrackingCallbacks;
    /**
     * Camera configuration (MediaStreamConstraints['video'])
     * @default { facingMode: 'environment', width: { ideal: 1280 }, height: { ideal: 960 } }
     */
    cameraConfig?: MediaStreamConstraints['video'];
    /**
     * Viewport width for processing
     * @default 1280
     */
    viewportWidth?: number;
    /**
     * Viewport height for processing
     * @default 960
     */
    viewportHeight?: number;
    /**
     * Enable debug mode for additional logging
     * @default false
     */
    debugMode?: boolean;
    /**
     * Enable bio-inspired perception optimizations
     * @default true
     */
    bioInspiredEnabled?: boolean;
    /**
     * Scale multiplier for the overlay
     * @default 1.0
     */
    scale?: number;
}
/**
 * Tracker instance returned by createTracker
 */
export interface Tracker {
    /** Start tracking from device camera */
    startCamera(): Promise<void>;
    /** Start tracking from a video or canvas element */
    startVideo(source: HTMLVideoElement | HTMLCanvasElement): void;
    /** Stop tracking and release resources */
    stop(): void;
    /** Whether the tracker is currently active */
    readonly isActive: boolean;
    /** Whether a target is currently being tracked */
    readonly isTracking: boolean;
    /** The underlying BioInspiredController instance */
    readonly controller: BioInspiredController;
    /** Target dimensions [width, height] */
    readonly targetDimensions: [number, number];
    /** Get the projection matrix for 3D rendering */
    getProjectionMatrix(): number[];
}
/**
 * Create and configure an AR tracker with minimal setup
 */
export declare function createTracker(config: TrackerConfig): Promise<Tracker>;
/**
 * Convenience function to create a tracker with camera autostart
 */
export declare function startTracking(config: TrackerConfig): Promise<Tracker>;
export default createTracker;