/**
 * Performance Utilities for NA-Kit UI
 *
 * Provides debounce, throttle, memoize, idle callback management,
 * performance monitoring, and bundle-size helpers.
 *
 * @module performance
 */
/**
 * Debounce a function call — delays execution until after `delay` ms
 * of no further calls.
 *
 * @example
 * ```ts
 * const handleSearch = debounce((query: string) => {
 *   fetchResults(query);
 * }, 300);
 * ```
 */
export declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number, options?: {
    leading?: boolean;
    trailing?: boolean;
    maxWait?: number;
}): T & {
    cancel: () => void;
    flush: () => void;
};
/**
 * Throttle a function — ensures it's called at most once every `limit` ms.
 *
 * @example
 * ```ts
 * const handleScroll = throttle(() => {
 *   updateUI();
 * }, 100);
 * ```
 */
export declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, limit: number, options?: {
    leading?: boolean;
    trailing?: boolean;
}): T & {
    cancel: () => void;
};
/**
 * Memoize a function — cache results based on arguments.
 * Includes TTL and max size for memory management.
 */
export declare function memoize<T extends (...args: unknown[]) => unknown>(fn: T, options?: {
    /** Cache key generator */
    keyFn?: (...args: unknown[]) => string;
    /** Time-to-live in ms (0 = no expiry) */
    ttl?: number;
    /** Maximum cache size */
    maxSize?: number;
}): T & {
    cache: Map<string, unknown>;
    clear: () => void;
};
/**
 * Schedule work during idle periods (with fallback)
 */
export declare function scheduleIdle(callback: () => void, options?: {
    timeout?: number;
}): number;
/**
 * Cancel a scheduled idle callback
 */
export declare function cancelIdle(id: number): void;
/**
 * Schedule work using requestAnimationFrame
 */
export declare function scheduleFrame(callback: () => void): number;
/**
 * Batch DOM reads and writes to avoid layout thrashing
 */
declare class DOMSchedulerImpl {
    private _reads;
    private _writes;
    private _scheduled;
    /** Schedule a DOM read */
    read(fn: () => void): void;
    /** Schedule a DOM write */
    write(fn: () => void): void;
    /** Schedule a measure + mutate pair */
    measure(fn: () => void): void;
    mutate(fn: () => void): void;
    private _schedule;
}
/** Singleton DOM scheduler for avoiding layout thrashing */
export declare const DOMScheduler: DOMSchedulerImpl;
export interface PerformanceMetrics {
    /** First Contentful Paint */
    fcp?: number;
    /** Largest Contentful Paint */
    lcp?: number;
    /** First Input Delay */
    fid?: number;
    /** Cumulative Layout Shift */
    cls?: number;
    /** Time to Interactive */
    tti?: number;
    /** Component render times */
    renderTimes: Map<string, number[]>;
}
/**
 * Performance monitor for tracking component render times and Web Vitals
 */
export declare class PerformanceMonitor {
    private _metrics;
    private _observers;
    private _active;
    /** Start monitoring */
    start(): void;
    /** Stop monitoring */
    stop(): void;
    /** Mark the start of a component render */
    markRenderStart(componentName: string): void;
    /** Mark the end of a component render and record duration */
    markRenderEnd(componentName: string): number;
    /** Get average render time for a component */
    getAverageRenderTime(componentName: string): number;
    /** Get all metrics */
    getMetrics(): PerformanceMetrics;
    /** Reset all metrics */
    reset(): void;
}
/**
 * Run tasks in batches to avoid blocking the main thread
 */
export declare function processBatch<T, R>(items: T[], processor: (item: T, index: number) => R, batchSize?: number, yieldInterval?: number): Promise<R[]>;
/**
 * Wait for the next animation frame
 */
export declare function nextFrame(): Promise<number>;
/**
 * Wait for the next microtask
 */
export declare function nextTick(): Promise<void>;
/**
 * Observe element resize events efficiently using ResizeObserver
 */
export declare function observeResize(element: Element, callback: (entry: ResizeObserverEntry) => void): () => void;
export {};
//# sourceMappingURL=performance.d.ts.map