interface IMonitorWarning {
    FCP?: number;
    LCP: number;
    TTI?: number;
    FID?: number;
    INP?: number;
    CLS?: number;
}
interface PerformanceMonitorMetrics extends Required<IMonitorWarning> {
    DNS?: number;
    TCP?: number;
    SSL?: number;
    TTFB?: number;
    FMP?: number;
    DCL?: number;
    LCPElement?: string;
    networkType?: string;
    deviceType?: string;
    memory?: number;
    cpuCores?: number;
}
interface PerformanceMonitorOps {
    warnings: IMonitorWarning;
    reportUrl: string;
    appId: string;
    debug?: boolean;
    isDev?: boolean;
    maxTime?: number;
    deviceType?: 'mobile' | 'desktop' | 'auto';
    networkType?: 'unknown' | '2g' | '3g' | '4g' | '5g' | 'slow-2g' | 'wifi' | 'ethernet';
    pageInfo?: {
        pageUrl: string;
        pageTitle: string;
        routeId?: string;
    };
}
interface IReportData {
    appId: string;
    timestamp: string;
    metrics: PerformanceMonitorMetrics;
    userAgent: string;
    pageInfo?: {
        pageUrl: string;
        pageTitle: string;
        routeId?: string;
    };
    warnings: string[];
    environment: {
        networkType?: string;
        deviceType?: string;
        memory?: number;
        cpuCores?: number;
    };
}
interface PerformancePanelJank {
    /** 小卡顿 */
    small: number;
    /** 中卡顿 */
    medium: number;
    /** 大卡顿 */
    large: number;
    /** 卡顿率 */
    stutterRate: number;
    /** 严重卡顿率 */
    severeJankRate: number;
}
/**
 * 事件计时指标
 */
interface EventTimingMetrics {
    /** 平均事件处理延迟时间(ms) */
    avgDelay: number;
    /** 最大事件处理延迟时间(ms) */
    maxDelay: number;
}
interface PerformancePanelMetrics {
    /** FPS */
    fps: number;
    /** 卡顿 */
    jank: PerformancePanelJank;
    /** 帧耗时 */
    frameTimes: number[];
    /** 事件计时 (可选，仅在支持 Event Timing API 时提供) */
    eventTiming?: EventTimingMetrics;
}

declare class PerformanceMonitor {
    private readonly config;
    private metrics;
    private isStarted;
    isReported: boolean;
    private isStopped;
    private observers;
    private reportTimer;
    private lcpEntries;
    private inpEntries;
    private clsValue;
    private ttiResolve?;
    constructor(options?: PerformanceMonitorOps);
    private detectDeviceType;
    private detectNetworkType;
    private getDeviceMemory;
    private getCPUCores;
    private initPerfTiming;
    private logDebug;
    start(): void;
    private resetForNextRoute;
    report(): void;
    private checkWarnings;
    private renderReport;
    private sendReport;
    dispose(): void;
}

/**
 * RadarReport - Enhanced frontend monitoring data reporting class
 * Handles reliable data transmission with queue management, batching, and retry mechanisms
 */
declare class RadarReport<T extends unknown = {}> {
    private queue;
    private sending;
    private retryQueue;
    private retryAttempts;
    private maxRetries;
    private maxQueueSize;
    private maxRetryQueueSize;
    private batchSize;
    private processingTimeout;
    private readonly STORAGE_KEY;
    reportUrl: string;
    constructor(config?: {
        reportUrl?: string;
        maxRetries?: number;
        maxQueueSize?: number;
        maxRetryQueueSize?: number;
        batchSize?: number;
    });
    /**
     * Public method to report monitoring data
     * @param data The data to report
     * @param priority Optional priority level (higher = more important)
     */
    report(data: T, priority?: number): void;
    /**
     * Schedule queue processing with debounce to avoid frequent processing
     */
    private scheduleQueueProcessing;
    /**
     * Process the queue in chunks to avoid blocking the main thread
     */
    private processQueue;
    /**
     * Process a chunk of the queue to avoid long-running operations
     */
    private processQueueChunk;
    /**
     * Send a batch of data with error handling
     */
    private sendBatch;
    /**
     * Handle send errors with progressive retry and fallback strategies
     */
    private handleSendError;
    /**
     * Store data offline when network requests fail permanently
     */
    private storeOfflineData;
    /**
     * Get offline data from localStorage
     */
    private getOfflineData;
    /**
     * Recover offline data on initialization
     */
    private recoverOfflineData;
    /**
     * Persist any pending data when page unloads
     */
    private persistOfflineData;
    /**
     * Find the index of the lowest priority item in the queue
     */
    private findLowestPriorityItemIndex;
    /**
     * Generate a truly unique ID for batch tracking
     */
    private generateUniqueId;
    /**
     * Get current queue statistics for monitoring
     */
    getQueueStats(): {
        mainQueue: number;
        retryQueue: number;
        activeSending: boolean;
        offlineData: number;
        configuration: {
            batchSize: number;
            maxQueueSize: number;
            maxRetryQueueSize: number;
            maxRetries: number;
        };
    };
    /**
     * Get count of offline data items
     */
    private getOfflineDataCount;
    /**
     * Manually flush all queues (useful for testing or before page unload)
     */
    flush(): Promise<void>;
    /**
     * Clear all queues and offline data (useful for testing or user opt-out)
     */
    clear(): void;
}

declare abstract class PerformanceBase<T extends unknown = {}> {
    protected readonly worker: Worker | null;
    protected metrics: Record<string, number | string>;
    private radarPlugin;
    onUpdate?: (data: T) => void;
    constructor();
    use(plugin: RadarReport<T>): this;
    protected abstract startMonitoring(): void;
    protected abstract stopMonitoring(): void;
    private handleWorkerMessage;
    protected postToWorker(message: object): void;
    destroy(): void;
}

interface PanelJankOps {
    title?: string;
    left?: number;
    width?: number;
    height?: number;
    isExpanded?: boolean;
}
declare class PanelJank {
    private panel;
    /** 是否展开 */
    private isExpanded;
    private metrics;
    private panelInfo?;
    constructor(ops?: PanelJankOps);
    initPanel(): void;
    bindEvents(): void;
    updateMetrics(data: PerformancePanelMetrics): void;
    render(): void;
    destroy(): void;
}
declare function initPanelJank(): PanelJank;

interface JankStutterOptions {
    /**
     * 帧率
     * 默认16.67，单位：ms
     */
    frame?: number;
    /**
     * 设备刷新率
     * 默认60，单位：Hz
     */
    deviceRefreshRate?: number;
    /**
     * 事件处理延迟阈值（小卡顿）
     * 默认50ms
     */
    minJankThreshold?: number;
    /**
     * 事件处理延迟阈值（大卡顿）
     * 默认100ms
     */
    largeJankThreshold?: number;
    /**
     * 数据更新间隔
     * 默认1000ms
     */
    updateInterval?: number;
}
declare class PerformanceJankStutter extends PerformanceBase {
    private frameTimes;
    private jankCounts;
    /** 帧率 */
    frame: number;
    /** 设备刷新率 */
    deviceRefreshRate: number;
    /** 事件延迟阈值（小卡顿）*/
    minJankThreshold: number;
    /** 事件延迟阈值（大卡顿）*/
    largeJankThreshold: number;
    /** 数据更新间隔 */
    updateInterval: number;
    /** 性能观察器 */
    private performanceObserver;
    /** 定时更新器 */
    private updateTimer;
    /** 收集的事件数据 */
    private eventEntries;
    /** RAF ID */
    private rafId;
    constructor(ops?: JankStutterOptions);
    startMonitoring(): void;
    /**
     * 启动基于 PerformanceObserver 的事件计时监测
     */
    private startEventTimingMonitor;
    /**
     * 启动基于 RAF 的帧率监测
     */
    private startFrameRateMonitor;
    /**
     * 传统的卡顿监测方式（兼容性保障）
     */
    private startLegacyMonitor;
    /**
     * 更新并发送性能指标
     */
    private updateMetrics;
    stopMonitoring(): void;
}
declare function useJankStutter(opsJank?: JankStutterOptions, opsPanel?: PanelJankOps): {
    panelJank: PanelJank;
};

declare class PanelJankPerformance {
    private panel;
    private content;
    private isExpanded;
    private isDragging;
    private dragOffset;
    private metrics;
    constructor();
    private createPanel;
    private enableDrag;
    updateMetrics(data: PerformancePanelJank): void;
    private render;
    private drawFrameTimeChart;
}

export { PanelJank, PanelJankPerformance, PerformanceBase, PerformanceJankStutter, PerformanceMonitor, RadarReport, initPanelJank, useJankStutter };
export type { EventTimingMetrics, IMonitorWarning, IReportData, JankStutterOptions, PanelJankOps, PerformanceMonitorMetrics, PerformanceMonitorOps, PerformancePanelJank, PerformancePanelMetrics };