import { default as React, ComponentType, ReactNode } from 'react';
export declare function lazyWithRetry<T extends ComponentType<any>>(importFn: () => Promise<{
    default: T;
}>, retries?: number, delay?: number): React.LazyExoticComponent<T>;
export interface PreloadableComponent<T extends ComponentType<any>> {
    Component: React.LazyExoticComponent<T>;
    preload: () => Promise<void>;
}
export declare function lazyWithPreload<T extends ComponentType<any>>(importFn: () => Promise<{
    default: T;
}>): PreloadableComponent<T>;
export interface ProgressiveOptions {
    fallback?: ReactNode;
    errorFallback?: ReactNode;
    loadingDelay?: number;
    minimumLoadingTime?: number;
}
export declare function createProgressiveComponent<T extends ComponentType<any>>(importFn: () => Promise<{
    default: T;
}>, options?: ProgressiveOptions): any;
export declare function useLazyLoad(ref: React.RefObject<HTMLElement>, options?: globalThis.IntersectionObserverInit): boolean;
export interface LazyWrapperProps {
    children: ReactNode;
    fallback?: ReactNode;
    threshold?: number;
    rootMargin?: string;
    placeholder?: ReactNode;
}
export declare const LazyWrapper: React.FC<LazyWrapperProps>;
export interface LazyRouteConfig<T extends ComponentType<any>> {
    path: string;
    importFn: () => Promise<{
        default: T;
    }>;
    preloadOnHover?: boolean;
    preloadOnFocus?: boolean;
    prefetchDelay?: number;
}
export declare function createLazyRoute<T extends ComponentType<any>>(config: LazyRouteConfig<T>): {
    Component: React.LazyExoticComponent<T>;
    preload: () => Promise<{
        default: T;
    }>;
    linkProps: {
        onFocus?: (() => void) | undefined;
        onMouseEnter?: (() => void) | undefined;
        onMouseLeave?: (() => void) | undefined;
    };
};
export declare function useDynamicImport<T>(importFn: () => Promise<T>, deps?: React.DependencyList): {
    module: T | null;
    loading: boolean;
    error: Error | null;
};
export declare class LazyLoadQueue {
    private queue;
    private isProcessing;
    private batchSize;
    private delay;
    constructor(batchSize?: number, delay?: number);
    add(loadFn: () => Promise<any>): void;
    private process;
}
export declare function addResourceHint(url: string, type: 'prefetch' | 'preload' | 'preconnect' | 'dns-prefetch', as?: string): void;
export declare enum LoadPriority {
    HIGH = 0,
    MEDIUM = 1,
    LOW = 2,
    IDLE = 3
}
export declare class PriorityLoader {
    private queues;
    private isProcessing;
    constructor();
    load(fn: () => Promise<any>, priority?: LoadPriority): void;
    private process;
}
export declare const lazyLoadQueue: LazyLoadQueue;
export declare const priorityLoader: PriorityLoader;
declare const _default: {
    lazyWithRetry: typeof lazyWithRetry;
    lazyWithPreload: typeof lazyWithPreload;
    createProgressiveComponent: typeof createProgressiveComponent;
    useLazyLoad: typeof useLazyLoad;
    LazyWrapper: React.FC<LazyWrapperProps>;
    createLazyRoute: typeof createLazyRoute;
    useDynamicImport: typeof useDynamicImport;
    LazyLoadQueue: typeof LazyLoadQueue;
    addResourceHint: typeof addResourceHint;
    PriorityLoader: typeof PriorityLoader;
    LoadPriority: typeof LoadPriority;
    lazyLoadQueue: LazyLoadQueue;
    priorityLoader: PriorityLoader;
};
export default _default;
//# sourceMappingURL=lazy-loading.d.ts.map