import React from 'react';

interface EngineConfig {
    itemHeight: number;
    viewportHeight: number;
    bufferSize?: number;
    totalItems?: number;
}
interface VisibleRange {
    start: number;
    end: number;
}
interface FetchMoreCallback {
    (): Promise<any>;
}
interface ScrollAnalysis {
    velocity: number;
    direction: 'up' | 'down' | 'stationary';
    buffer: number;
    prefetchDistance: number;
    predictedPosition: number;
    isIdle: boolean;
}

interface LazyListConfig extends EngineConfig {
    fetchMore: FetchMoreCallback;
}
declare const useLazyList: (config: LazyListConfig) => {
    visibleRange: VisibleRange;
    loadedItems: any[];
    isLoading: boolean;
    scrollAnalysis: ScrollAnalysis;
    setContainerRef: (element: HTMLElement | null) => (() => void) | undefined;
    refresh: () => void;
    getScrollAnalysis: () => {
        velocity: number;
        direction: string;
        buffer: number;
        prefetchDistance: number;
        predictedPosition: number;
        isIdle: boolean;
    };
};

interface LazyListProps extends EngineConfig {
    fetchMore: FetchMoreCallback;
    renderItem: (item: any, index: number) => React.ReactNode;
    items: any[];
    className?: string;
    style?: React.CSSProperties;
}
declare const LazyList: React.ForwardRefExoticComponent<LazyListProps & React.RefAttributes<HTMLDivElement>>;

/**
 * Intelligent Pagination
 * Adaptive page size with cursor-based pagination
 */
interface PaginationState {
    currentPage: number;
    pageSize: number;
    totalItems: number;
    totalPages: number;
    hasMore: boolean;
    cursor?: string;
    nextCursor?: string;
    prevCursor?: string;
}

interface UseIntelligentScrollConfig {
    itemHeight?: number;
    viewportHeight?: number;
    bufferSize?: number;
    fetchMore: FetchMoreCallback;
    enablePrefetch?: boolean;
    enableCache?: boolean;
    cacheSize?: number;
}
interface IntelligentScrollState {
    visibleRange: VisibleRange;
    isLoading: boolean;
    scrollVelocity: number;
    scrollDirection: 'up' | 'down' | 'stationary';
    scrollPattern: 'fast-scroll' | 'slow-scroll' | 'paused' | 'oscillating' | 'steady';
    prefetchConfidence: number;
    cacheHitRate: number;
    totalItems: number;
}
declare const useIntelligentScroll: (config: UseIntelligentScrollConfig) => {
    visibleRange: VisibleRange;
    isLoading: boolean;
    scrollVelocity: number;
    scrollDirection: "up" | "down" | "stationary";
    scrollPattern: "fast-scroll" | "slow-scroll" | "paused" | "oscillating" | "steady";
    prefetchConfidence: number;
    cacheHitRate: number;
    totalItems: number;
    setContainerRef: (element: HTMLElement | null) => (() => void) | undefined;
    getCachedData: (index: number) => any;
    cacheData: (index: number, data: any, priority?: "low" | "normal" | "high" | "critical") => void;
    getPaginationState: () => PaginationState | null;
    refresh: () => void;
};

interface UseAdaptiveLoadingConfig {
    initialBatchSize?: number;
    minBatchSize?: number;
    maxBatchSize?: number;
    fetchMore: () => Promise<any[]>;
    enableNetworkAdaptation?: boolean;
    enablePerformanceAdaptation?: boolean;
}
interface AdaptiveLoadingState {
    currentBatchSize: number;
    networkQuality: 'excellent' | 'good' | 'poor' | 'offline';
    performanceScore: number;
    isLoading: boolean;
    loadedItems: number;
    avgLoadTime: number;
    adaptationCount: number;
}
declare const useAdaptiveLoading: (config: UseAdaptiveLoadingConfig) => {
    loadMore: () => Promise<any[]>;
    getCurrentBatchSize: () => number;
    getStats: () => {
        currentBatchSize: number;
        networkQuality: "excellent" | "good" | "poor" | "offline";
        performanceScore: number;
        avgLoadTime: number;
        adaptationCount: number;
        loadedItems: number;
    };
    reset: () => void;
    currentBatchSize: number;
    networkQuality: "excellent" | "good" | "poor" | "offline";
    performanceScore: number;
    isLoading: boolean;
    loadedItems: number;
    avgLoadTime: number;
    adaptationCount: number;
};

interface UseSmartPaginationConfig {
    initialPage?: number;
    initialPageSize?: number;
    minPageSize?: number;
    maxPageSize?: number;
    enableAdaptation?: boolean;
}
interface SmartPaginationState {
    currentPage: number;
    pageSize: number;
    totalItems: number;
    totalPages: number;
    hasMore: boolean;
    cursor?: string;
    nextCursor?: string;
    prevCursor?: string;
    avgLoadTime: number;
    isAdapting: boolean;
}
declare const useSmartPagination: (config?: UseSmartPaginationConfig) => {
    nextPage: (loadDataFn?: () => Promise<void>) => Promise<void>;
    prevPage: () => void;
    goToPage: (page: number) => void;
    goToCursor: (cursor: string) => void;
    setTotalItems: (total: number) => void;
    getFetchRange: () => {
        skip: number;
        limit: number;
    };
    getCurrentCursor: () => string | undefined;
    getStats: () => {
        currentPage: number;
        pageSize: number;
        totalItems: number;
        totalPages: number;
        hasMore: boolean;
        avgLoadTime: number;
        currentCursor: string | undefined;
        loadHistory: {
            page: number;
            time: number;
        }[];
    } | null;
    reset: () => void;
    currentPage: number;
    pageSize: number;
    totalItems: number;
    totalPages: number;
    hasMore: boolean;
    cursor?: string;
    nextCursor?: string;
    prevCursor?: string;
    avgLoadTime: number;
    isAdapting: boolean;
};

interface IntelligentLazyListProps {
    items: any[];
    itemHeight: number;
    viewportHeight: number;
    fetchMore: () => Promise<any[]>;
    renderItem: (item: any, index: number) => React.ReactNode;
    bufferSize?: number;
    enablePrefetch?: boolean;
    enableCache?: boolean;
    className?: string;
    style?: React.CSSProperties;
}
declare const IntelligentLazyList: React.FC<IntelligentLazyListProps>;

interface AdaptiveScrollViewProps {
    children: React.ReactNode;
    fetchMore: () => Promise<any[]>;
    initialBatchSize?: number;
    minBatchSize?: number;
    maxBatchSize?: number;
    enableNetworkAdaptation?: boolean;
    enablePerformanceAdaptation?: boolean;
    className?: string;
    style?: React.CSSProperties;
    onLoadMore?: (items: any[]) => void;
}
declare const AdaptiveScrollView: React.FC<AdaptiveScrollViewProps>;

interface SmartInfiniteScrollProps {
    fetchMore: (page: number, limit: number) => Promise<any[]>;
    renderItem: (item: any, index: number) => React.ReactNode;
    initialPageSize?: number;
    minPageSize?: number;
    maxPageSize?: number;
    enableAdaptation?: boolean;
    className?: string;
    style?: React.CSSProperties;
    emptyMessage?: string;
}
declare const SmartInfiniteScroll: React.FC<SmartInfiniteScrollProps>;

/**
 * Performance Analytics Engine
 * Tracks render time, memory usage, and network performance
 */
interface PerformanceMetrics {
    renderTime: {
        average: number;
        min: number;
        max: number;
        count: number;
    };
    memoryUsage: {
        current: number;
        peak: number;
        trend: 'increasing' | 'stable' | 'decreasing';
    };
    networkPerformance: {
        averageLatency: number;
        averageSpeed: number;
        failedRequests: number;
    };
    scrollPerformance: {
        averageFPS: number;
        droppedFrames: number;
        jankCount: number;
    };
}
declare class PerformanceAnalytics {
    private renderTimeHistory;
    private memoryHistory;
    private networkLatencyHistory;
    private frameTimestamps;
    private droppedFrames;
    private jankCount;
    private readonly MAX_HISTORY;
    private readonly JANK_THRESHOLD;
    /**
     * Track render time for an item
     */
    trackRenderTime(renderTime: number): void;
    /**
     * Track memory usage
     */
    trackMemoryUsage(memoryMB: number): void;
    /**
     * Track network request latency
     */
    trackNetworkLatency(latency: number): void;
    /**
     * Track frame timing for FPS calculation
     */
    trackFrame(): void;
    /**
     * Get current FPS
     */
    getCurrentFPS(): number;
    /**
     * Get comprehensive performance metrics
     */
    getMetrics(): PerformanceMetrics;
    /**
     * Get average from array
     */
    private getAverage;
    /**
     * Get trend from array
     */
    private getTrend;
    /**
     * Reset all metrics
     */
    reset(): void;
    /**
     * Get performance score (0-100)
     */
    getPerformanceScore(): number;
    /**
     * Get optimization recommendations
     */
    getRecommendations(): string[];
}

interface PerformanceMonitorProps {
    analytics: PerformanceAnalytics;
    showOverlay?: boolean;
    position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
}
declare const PerformanceMonitor: React.FC<PerformanceMonitorProps>;

export { AdaptiveScrollView, IntelligentLazyList, LazyList, PerformanceMonitor, SmartInfiniteScroll, useAdaptiveLoading, useIntelligentScroll, useLazyList, useSmartPagination };
export type { AdaptiveLoadingState, AdaptiveScrollViewProps, IntelligentLazyListProps, IntelligentScrollState, PerformanceMonitorProps, SmartInfiniteScrollProps, SmartPaginationState, UseAdaptiveLoadingConfig, UseIntelligentScrollConfig, UseSmartPaginationConfig };