import { QueryClient } from '@tanstack/react-query';
/**
 * Navigation event for pattern learning
 */
export interface NavigationEvent {
    from: string;
    to: string;
    timestamp: number;
    sessionId: string;
    timeOfDay: 'morning' | 'afternoon' | 'evening' | 'night';
    dayOfWeek: number;
}
/**
 * Route configuration for prefetching
 */
export interface PrefetchableRoute {
    /** Route path pattern */
    path: string;
    /** Module loader for code splitting */
    loader?: () => Promise<unknown>;
    /** Query configuration for data prefetching */
    queries?: Array<{
        queryKey: readonly unknown[];
        queryFn: () => Promise<unknown>;
        staleTime?: number;
    }>;
    /** Static assets to preload */
    assets?: string[];
    /** Estimated load priority (0-10) */
    priority?: number;
}
/**
 * Prediction result
 */
export interface RoutePrediction {
    route: string;
    probability: number;
    confidence: 'high' | 'medium' | 'low';
    source: 'markov' | 'time-pattern' | 'session-context' | 'static';
}
/**
 * Transition matrix for Markov chain
 */
type TransitionMatrix = Map<string, Map<string, number>>;
/**
 * Time pattern entry
 */
interface TimePattern {
    route: string;
    timeOfDay: string;
    dayOfWeek: number;
    count: number;
}
/**
 * Configuration for predictive prefetch
 */
export interface PredictivePrefetchConfig {
    /** Enable learning from navigation */
    enableLearning?: boolean;
    /** Probability threshold for triggering prefetch (0-1) */
    probabilityThreshold?: number;
    /** Maximum routes to prefetch at once */
    maxPrefetchCount?: number;
    /** Storage key for persisting learned patterns */
    storageKey?: string;
    /** Static route priorities (fallback) */
    staticRoutes?: Record<string, number>;
    /** Network quality threshold ('4g' | '3g' | '2g' | 'slow-2g') */
    minNetworkQuality?: string;
    /** Respect user's data saver preference */
    respectDataSaver?: boolean;
    /** Debug logging */
    debug?: boolean;
    /** Decay factor for old transitions (0-1) */
    decayFactor?: number;
    /** Maximum history entries to keep */
    maxHistorySize?: number;
}
/**
 * Predictive prefetch engine that learns navigation patterns
 */
export declare class PredictivePrefetchEngine {
    private config;
    private transitionMatrix;
    private timePatterns;
    private sessionHistory;
    private routeRegistry;
    private prefetchedRoutes;
    private queryClient;
    constructor(config?: PredictivePrefetchConfig);
    /**
     * Initialize with query client for data prefetching
     */
    setQueryClient(client: QueryClient): void;
    /**
     * Register routes available for prefetching
     */
    registerRoutes(routes: PrefetchableRoute[]): void;
    /**
     * Record a navigation event for learning
     */
    recordNavigation(from: string, to: string): void;
    /**
     * Get predicted next routes from current page
     */
    getPredictions(currentPath: string): RoutePrediction[];
    /**
     * Execute prefetch for predicted routes
     */
    prefetchPredictedRoutes(currentPath: string): Promise<void>;
    /**
     * Prefetch a specific route
     */
    prefetchRoute(routePath: string): Promise<void>;
    /**
     * Clear all learned patterns
     */
    clearPatterns(): void;
    /**
     * Get analytics about learned patterns
     */
    getAnalytics(): {
        totalTransitions: number;
        uniqueRoutes: number;
        timePatterns: number;
        topRoutes: Array<{
            route: string;
            visits: number;
        }>;
    };
    /**
     * Update transition matrix with new navigation
     */
    private updateTransitionMatrix;
    /**
     * Update time-based patterns
     */
    private updateTimePatterns;
    /**
     * Get predictions from transition matrix (Markov chain)
     */
    private getMarkovPredictions;
    /**
     * Get predictions based on time patterns
     */
    private getTimePatternPredictions;
    /**
     * Get predictions based on session context
     */
    private getSessionContextPredictions;
    /**
     * Get static route predictions
     */
    private getStaticPredictions;
    /**
     * Deduplicate predictions, keeping highest probability
     */
    private deduplicatePredictions;
    /**
     * Get confidence level from probability
     */
    private getConfidence;
    /**
     * Preload a static asset
     */
    private preloadAsset;
    /**
     * Check if prefetching should proceed
     */
    private shouldPrefetch;
    /**
     * Persist learned patterns to storage
     */
    private persistPatterns;
    /**
     * Load persisted patterns from storage
     */
    private loadPersistedPatterns;
    private log;
}
/**
 * Get or create the global PredictivePrefetchEngine instance
 */
export declare function getPredictivePrefetchEngine(config?: PredictivePrefetchConfig): PredictivePrefetchEngine;
/**
 * Hook options for usePredictivePrefetch
 */
export interface UsePredictivePrefetchOptions {
    /** Enable automatic prefetching on route change */
    autoPrefetch?: boolean;
    /** Delay before prefetching (ms) */
    prefetchDelay?: number;
}
/**
 * Create navigation listener for automatic tracking
 */
export declare function createNavigationListener(engine: PredictivePrefetchEngine, options?: UsePredictivePrefetchOptions): (location: {
    pathname: string;
}) => void;
export type { TransitionMatrix, TimePattern };