/**
 * Atlas Rebuild Queue - Async rebuild infrastructure
 *
 * Provides event-driven Atlas rebuild with debouncing to handle
 * rapid Frame ingestion without blocking operations.
 *
 * Features:
 * - Event-driven: Frame ingestion triggers rebuild via callbacks
 * - Async: Rebuilds don't block Frame storage operations
 * - Debouncing: Batches multiple rapid Frame ingestions
 * - In-memory queue: Simple, fast, no external dependencies
 */
import type { Frame } from "../types/frame.js";
import { type Atlas } from "./rebuild.js";
/**
 * Callback functions for Atlas rebuild events
 */
export interface AtlasRebuildCallbacks {
    onFrameIngested?: (frame: Frame) => void;
    onRebuildStarted?: () => void;
    onRebuildCompleted?: (atlas: Atlas) => void;
    onRebuildFailed?: (error: Error) => void;
}
/**
 * Configuration for AtlasRebuildQueue
 */
export interface AtlasRebuildQueueConfig {
    /** Debounce interval in milliseconds (default: 5000 = 5s) */
    debounceMs?: number;
    /** Whether to validate Atlas after rebuild (default: true) */
    validateAfterRebuild?: boolean;
    /** Callback to fetch all frames for rebuild */
    fetchFrames: () => Promise<Frame[]> | Frame[];
    /** Event callbacks */
    callbacks?: AtlasRebuildCallbacks;
}
/**
 * Atlas Rebuild Queue
 *
 * Manages async Atlas rebuilds triggered by Frame ingestion events.
 * Implements debouncing to batch rapid Frame ingestions.
 *
 * Usage:
 * ```typescript
 * const queue = new AtlasRebuildQueue({
 *   fetchFrames: () => frameStore.getAllFrames(),
 *   debounceMs: 5000,
 *   callbacks: {
 *     onRebuildCompleted: (atlas) => {
 *       console.log('Atlas rebuilt:', atlas);
 *     },
 *   },
 * });
 *
 * // Trigger rebuild when Frame is ingested
 * await frameStore.insertFrame(newFrame);
 * queue.notifyFrameIngested(newFrame);
 * ```
 */
export declare class AtlasRebuildQueue {
    private config;
    private callbacks;
    private debounceTimer;
    private isRebuilding;
    private pendingRebuild;
    constructor(config: AtlasRebuildQueueConfig);
    /**
     * Notify queue that a Frame was ingested
     *
     * This triggers a debounced rebuild - if multiple Frames are ingested
     * rapidly, only one rebuild will occur after the debounce period.
     *
     * @param frame - The Frame that was ingested
     */
    notifyFrameIngested(frame: Frame): void;
    /**
     * Trigger rebuild immediately (bypasses debounce)
     *
     * Useful for testing or manual rebuild triggers.
     */
    triggerRebuild(): Promise<void>;
    /**
     * Stop the queue and cancel any pending rebuilds
     */
    stop(): void;
    /**
     * Check if rebuild is currently in progress
     */
    isRebuildInProgress(): boolean;
}
/**
 * Create a simple Atlas rebuild queue
 *
 * Convenience factory function for creating a queue with sensible defaults.
 *
 * @param fetchFrames - Function to fetch all frames
 * @param debounceMs - Debounce interval in milliseconds (default: 5000)
 * @param callbacks - Event callbacks
 * @returns Atlas rebuild queue
 */
export declare function createAtlasRebuildQueue(fetchFrames: () => Promise<Frame[]> | Frame[], debounceMs?: number, callbacks?: AtlasRebuildCallbacks): AtlasRebuildQueue;