/**
 * @file Prefetch Strategies
 * @description Multiple prefetch strategies for different use cases including
 * viewport-based, interaction-based, and time-based prefetching.
 *
 * Features:
 * - Viewport intersection prefetching
 * - Hover/focus prefetching
 * - Idle time prefetching
 * - Sequential prefetching
 * - Conditional prefetching
 * - Strategy composition
 */
/**
 * Prefetch strategy type
 */
export type PrefetchStrategyType = 'viewport' | 'hover' | 'focus' | 'idle' | 'sequential' | 'immediate' | 'conditional';
/**
 * Prefetch target
 */
export interface PrefetchTarget {
    url: string;
    type: 'document' | 'script' | 'style' | 'image' | 'font' | 'fetch';
    as?: string;
    crossOrigin?: 'anonymous' | 'use-credentials';
    importance?: 'high' | 'low' | 'auto';
}
/**
 * Strategy execution context
 */
export interface StrategyContext {
    networkQuality: '4g' | '3g' | '2g' | 'slow-2g' | 'unknown';
    dataSaver: boolean;
    viewportWidth: number;
    viewportHeight: number;
    isVisible: boolean;
    isIdle: boolean;
    memoryPressure: 'none' | 'moderate' | 'critical';
}
/**
 * Strategy result
 */
export interface StrategyResult {
    shouldPrefetch: boolean;
    targets: PrefetchTarget[];
    delay?: number;
    reason: string;
}
/**
 * Base strategy configuration
 */
export interface BaseStrategyConfig {
    /** Enable the strategy */
    enabled: boolean;
    /** Respect data saver preference */
    respectDataSaver: boolean;
    /** Minimum network quality required */
    minNetworkQuality: '4g' | '3g' | '2g' | 'slow-2g';
    /** Maximum memory pressure to allow prefetch */
    maxMemoryPressure: 'none' | 'moderate' | 'critical';
}
/**
 * Viewport strategy configuration
 */
export interface ViewportStrategyConfig extends BaseStrategyConfig {
    /** Root margin for intersection observer */
    rootMargin: string;
    /** Intersection threshold */
    threshold: number;
    /** Delay after intersection before prefetch */
    delay: number;
}
/**
 * Hover strategy configuration
 */
export interface HoverStrategyConfig extends BaseStrategyConfig {
    /** Delay after hover before prefetch */
    delay: number;
    /** Cancel if unhover before delay */
    cancelOnUnhover: boolean;
    /** Enable touch device support */
    touchSupport: boolean;
}
/**
 * Idle strategy configuration
 */
export interface IdleStrategyConfig extends BaseStrategyConfig {
    /** Timeout for idle callback */
    timeout: number;
    /** Minimum idle time required */
    minIdleTime: number;
}
/**
 * Sequential strategy configuration
 */
export interface SequentialStrategyConfig extends BaseStrategyConfig {
    /** Delay between sequential prefetches */
    intervalDelay: number;
    /** Maximum items to prefetch */
    maxItems: number;
    /** Prioritize by */
    prioritizeBy: 'order' | 'size' | 'importance';
}
/**
 * Conditional strategy configuration
 */
export interface ConditionalStrategyConfig extends BaseStrategyConfig {
    /** Condition function */
    condition: (context: StrategyContext) => boolean;
    /** Re-evaluate interval */
    reevaluateInterval: number;
}
/**
 * Abstract base class for prefetch strategies
 */
export declare abstract class PrefetchStrategy {
    protected config: BaseStrategyConfig;
    protected targets: PrefetchTarget[];
    protected constructor(config?: Partial<BaseStrategyConfig>);
    /**
     * Execute the strategy
     */
    abstract execute(context: StrategyContext): StrategyResult;
    /**
     * Add prefetch target
     */
    addTarget(target: PrefetchTarget): void;
    /**
     * Add multiple targets
     */
    addTargets(targets: PrefetchTarget[]): void;
    /**
     * Clear targets
     */
    clearTargets(): void;
    /**
     * Get current targets
     */
    getTargets(): PrefetchTarget[];
    /**
     * Check if prefetching should be allowed based on context
     */
    protected shouldAllowPrefetch(context: StrategyContext): {
        allowed: boolean;
        reason: string;
    };
}
/**
 * Prefetch when elements enter the viewport
 */
export declare class ViewportPrefetchStrategy extends PrefetchStrategy {
    private viewportConfig;
    private observer;
    private observedElements;
    private prefetchedUrls;
    private onPrefetch;
    constructor(config?: Partial<ViewportStrategyConfig>);
    execute(context: StrategyContext): StrategyResult;
    /**
     * Start observing an element
     */
    observe(element: Element, target: PrefetchTarget): void;
    /**
     * Stop observing an element
     */
    unobserve(element: Element): void;
    /**
     * Set prefetch callback
     */
    setOnPrefetch(callback: (target: PrefetchTarget) => void): void;
    /**
     * Disconnect observer
     */
    disconnect(): void;
    private initObserver;
    private handleIntersection;
}
/**
 * Prefetch on hover/focus
 */
export declare class HoverPrefetchStrategy extends PrefetchStrategy {
    private hoverConfig;
    private hoverTimers;
    private prefetchedUrls;
    private onPrefetch;
    constructor(config?: Partial<HoverStrategyConfig>);
    execute(context: StrategyContext): StrategyResult;
    /**
     * Handle hover start
     */
    handleHoverStart(target: PrefetchTarget): void;
    /**
     * Handle hover end
     */
    handleHoverEnd(target: PrefetchTarget): void;
    /**
     * Set prefetch callback
     */
    setOnPrefetch(callback: (target: PrefetchTarget) => void): void;
    /**
     * Create event handlers for an element
     */
    createHandlers(target: PrefetchTarget): {
        onMouseEnter: () => void;
        onMouseLeave: () => void;
        onFocus: () => void;
        onBlur: () => void;
        onTouchStart?: () => void;
    };
    /**
     * Cleanup all pending hovers
     */
    cleanup(): void;
}
/**
 * Prefetch during browser idle time
 */
export declare class IdlePrefetchStrategy extends PrefetchStrategy {
    private idleConfig;
    private idleCallbackId;
    private prefetchedUrls;
    private onPrefetch;
    constructor(config?: Partial<IdleStrategyConfig>);
    execute(context: StrategyContext): StrategyResult;
    /**
     * Schedule idle prefetch
     */
    scheduleIdlePrefetch(): void;
    /**
     * Cancel scheduled prefetch
     */
    cancel(): void;
    /**
     * Set prefetch callback
     */
    setOnPrefetch(callback: (target: PrefetchTarget) => void): void;
    private handleIdleCallback;
    private handleFallbackIdle;
}
/**
 * Prefetch resources sequentially with delays
 */
export declare class SequentialPrefetchStrategy extends PrefetchStrategy {
    private sequentialConfig;
    private prefetchedUrls;
    private currentIndex;
    private timer;
    private onPrefetch;
    constructor(config?: Partial<SequentialStrategyConfig>);
    execute(context: StrategyContext): StrategyResult;
    /**
     * Start sequential prefetching
     */
    start(): void;
    /**
     * Stop sequential prefetching
     */
    stop(): void;
    /**
     * Reset to beginning
     */
    reset(): void;
    /**
     * Set prefetch callback
     */
    setOnPrefetch(callback: (target: PrefetchTarget) => void): void;
    private prefetchNext;
    private getOrderedTargets;
}
/**
 * Prefetch based on custom conditions
 */
export declare class ConditionalPrefetchStrategy extends PrefetchStrategy {
    private conditionalConfig;
    private prefetchedUrls;
    private reevaluateTimer;
    private onPrefetch;
    constructor(config: Partial<ConditionalStrategyConfig> & {
        condition: (context: StrategyContext) => boolean;
    });
    execute(context: StrategyContext): StrategyResult;
    /**
     * Start periodic reevaluation
     */
    startReevaluation(getContext: () => StrategyContext): void;
    /**
     * Stop periodic reevaluation
     */
    stopReevaluation(): void;
    /**
     * Set prefetch callback
     */
    setOnPrefetch(callback: (target: PrefetchTarget) => void): void;
}
/**
 * Compose multiple strategies
 */
export declare class StrategyComposer {
    private strategies;
    private readonly mode;
    constructor(mode?: 'any' | 'all');
    /**
     * Add a strategy
     */
    add(name: string, strategy: PrefetchStrategy): this;
    /**
     * Remove a strategy
     */
    remove(name: string): boolean;
    /**
     * Execute all strategies
     */
    execute(context: StrategyContext): StrategyResult;
    private mergeTargets;
}
/**
 * Create a viewport-based prefetch strategy
 */
export declare function createViewportStrategy(config?: Partial<ViewportStrategyConfig>): ViewportPrefetchStrategy;
/**
 * Create a hover-based prefetch strategy
 */
export declare function createHoverStrategy(config?: Partial<HoverStrategyConfig>): HoverPrefetchStrategy;
/**
 * Create an idle-based prefetch strategy
 */
export declare function createIdleStrategy(config?: Partial<IdleStrategyConfig>): IdlePrefetchStrategy;
/**
 * Create a sequential prefetch strategy
 */
export declare function createSequentialStrategy(config?: Partial<SequentialStrategyConfig>): SequentialPrefetchStrategy;
/**
 * Create a conditional prefetch strategy
 */
export declare function createConditionalStrategy(config: Partial<ConditionalStrategyConfig> & {
    condition: (context: StrategyContext) => boolean;
}): ConditionalPrefetchStrategy;