import { ChartSeriesRenderer } from '../../renderer/ChartSeriesRenderer';
import { OverlayRenderer } from '../OverlayRenderer';
import { Series } from '../Series';
import { Scale } from '../../scales';
import { Bounds, AxisOptions, CursorOptions, PlotArea, ChartEventMap } from '../../types';
import { EventEmitter } from '../EventEmitter';
import { SelectionManager } from '../selection';
import { PluginManagerImpl } from '../../plugins';

export interface RenderLoopContext {
    webglCanvas: HTMLCanvasElement;
    overlayCanvas: HTMLCanvasElement;
    overlayCtx: CanvasRenderingContext2D;
    container: HTMLDivElement;
    series: Map<string, Series>;
    viewBounds: Bounds;
    xScale: Scale;
    yScales: Map<string, Scale>;
    yAxisOptionsMap: Map<string, AxisOptions>;
    xAxisOptions: AxisOptions;
    primaryYAxisId: string;
    renderer?: ChartSeriesRenderer;
    overlay: OverlayRenderer;
    backgroundColor: [number, number, number, number];
    plotAreaBackground: [number, number, number, number];
    getCursorOptions: () => CursorOptions | null;
    getCursorPosition: () => {
        x: number;
        y: number;
    } | null;
    selectionRect: {
        x: number;
        y: number;
        width: number;
        height: number;
    } | null;
    events: EventEmitter<ChartEventMap>;
    selectionManager: SelectionManager;
    getHoveredSeriesId: () => string | null;
    pluginManager: PluginManagerImpl;
    getLayout: () => import('../layout').LayoutOptions;
    getLatex: () => any;
    updateSeriesBuffer: (s: Series) => void;
    getPlotArea: () => PlotArea;
    pixelToDataX: (px: number) => number;
    pixelToDataY: (py: number, yAxisId?: string) => number;
    getBusinessDayMapping?: () => import('../time/TimeScale').BusinessDayMapping | null;
    getAlerts?: () => Array<{
        price: number;
        direction?: string;
    }>;
    get yScale(): Scale;
    /** Live SVG renderer root (when `renderer: 'svg'`). */
    svgRoot?: SVGSVGElement | null;
    /** Produce full SVG document string for vector renderer mode. */
    buildSVGFrame?: () => string;
    getActiveRenderer?: () => "webgl" | "webgpu" | "svg";
}
export declare class ChartRenderLoop {
    private ctx;
    private animationFrameId;
    private needsFullRender;
    private needsOverlayRender;
    private frameCount;
    private lastRenderTime;
    private initStarted;
    constructor(ctx: RenderLoopContext);
    /**
     * Mark that initialization has started
     */
    startInit(): void;
    /** Wire renderer after async WebGPU init (context holds a snapshot, not a live ref). */
    setRenderer(renderer: ChartSeriesRenderer): void;
    /** Swap the X scale (e.g. broken-axis plugin) — the context holds a snapshot. */
    setXScale(scale: Scale): void;
    /**
     * Check if init has started
     */
    isInitStarted(): boolean;
    /**
     * Request a full render (WebGL + overlay)
     */
    requestRender(): void;
    /**
     * Request overlay-only render
     */
    requestOverlayRender(): void;
    /**
     * Schedule render on next animation frame
     */
    private scheduleRenderFrame;
    /**
     * Perform an immediate full render (used after resize to avoid flicker).
     */
    flushRender(): void;
    /**
     * Cancel any pending render
     */
    cancelPendingRender(): void;
    /**
     * Perform the actual rendering
     */
    private performRender;
    /**
     * Get render statistics
     */
    getStats(): {
        frameCount: number;
        lastRenderTime: number;
        hasPendingRender: boolean;
        needsFullRender: boolean;
        needsOverlayRender: boolean;
    };
    /**
     * Reset frame counter
     */
    resetFrameCount(): void;
}