import type { SeriesConfig } from "../types";
export interface MultiEngineTickMutable {
    displayMin: number;
    displayMax: number;
    displayWindow: number;
    timestamp: number;
    /**
     * The right-edge time the engine would use if following live (`now (+ buffer)`).
     * Equals {@link timestamp} while following; keeps advancing while `timestamp`
     * stays frozen when scrolled back (see {@link MultiEngineTickInput.viewEnd}).
     */
    liveEdge: number;
    displayValues: number[];
    opacities: number[];
    /**
     * Value + time of the lowest / highest point across the visible series — the
     * actual extrema, NOT the smoothed display bounds. `NaN` when no visible
     * series has data in the window. Used to float `topLabel` / `bottomLabel` at
     * their occurrence point (see {@link AxisLabelConfig.position} `"extrema"`).
     */
    extremaMinValue: number;
    extremaMaxValue: number;
    extremaMinTime: number;
    extremaMaxTime: number;
    /** Previous frame's yRangeScale — detects an in-flight scale drag. */
    lastYRangeScale?: number;
}
export interface MultiEngineTickInput {
    dt: number;
    canvasWidth: number;
    canvasHeight: number;
    timeWindow: number;
    smoothing: number;
    exaggerate: boolean;
    /** Extra catch-up speed added to `smoothing` when a series tip lags. Default `0.12`. */
    adaptiveSpeedBoost?: number;
    referenceValue: number | undefined;
    /** Additional reference values (lines + bands) folded into the Y range. */
    referenceValues?: number[];
    /** Clamp the computed lower bound at 0. */
    nonNegative?: boolean;
    /** Hard cap for the computed upper bound. */
    maxValue?: number;
    /** Positive, finite Y-range multiplier around the fitted midpoint (1 = auto-fit). */
    yRangeScale?: number;
    series: SeriesConfig[];
    nowSeconds?: number;
    /** Override the engine's "now" (unix seconds). */
    nowOverride?: number;
    /** Right-edge buffer as a fraction of the time window. */
    windowBuffer?: number;
    paused?: boolean;
    /**
     * Settle the framing in this one frame instead of easing into it: the time
     * window, Y-range ({@link MultiEngineTickMutable.displayMin}/{@link MultiEngineTickMutable.displayMax}),
     * and per-series tips ({@link MultiEngineTickMutable.displayValues}) jump
     * straight to their targets — `smoothing` is bypassed for this tick only. Set
     * for the single frame after a `snapKey` change so a timeframe / dataset switch
     * lands instantly while live ticks keep their normal smoothing. Series-toggle
     * opacities and the timestamp / pan-scroll state are left untouched. See
     * {@link LiveChartSeriesProps.snapKey}.
     */
    snap?: boolean;
    /**
     * Absolute right-edge time (unix seconds) to freeze the window at, or
     * `null`/`undefined` to follow the live edge. Drives pan-scroll; takes
     * precedence over {@link paused}.
     */
    viewEnd?: number | null;
    /**
     * Honor a {@link viewEnd} parked at or past the live edge (blank future space)
     * instead of falling through to following live. Set when `timeScroll.overscroll`
     * is active. The `viewEnd >= firstDataTime` strand-guard applies in both modes.
     * Default `false` (classic behavior: only a past `viewEnd` freezes).
     */
    allowFutureViewEnd?: boolean;
    /**
     * "Return to live" glide (see #164). When time-scroll is disabled while scrolled
     * back, the hook clears {@link viewEnd} and animates {@link returnT} `0`→`1`;
     * each frame the right edge interpolates from {@link returnFrom} to the *current*
     * live edge by `returnT`, gliding onto live with no end-snap. `1`/`undefined`
     * pins to the live edge.
     */
    returnT?: number;
    /** Frozen right-edge time the {@link returnT} glide starts from. */
    returnFrom?: number;
    /**
     * Absolute visible-window width (seconds) to freeze at, or `null`/`undefined`
     * to follow {@link timeWindow}. Drives pinch-zoom (see `usePinchZoom`); the
     * symmetric counterpart of {@link viewEnd}.
     */
    viewWindow?: number | null;
}
/**
 * Multi-series frame tick: lerps per-series tips and visibility opacities,
 * combines Y-range over visible series (same margin rules as single-series).
 * Used by `useLiveChartSeriesEngine`.
 */
export declare function tickLiveChartSeriesEngineFrame(state: MultiEngineTickMutable, input: MultiEngineTickInput): void;
//# sourceMappingURL=liveChartSeriesEngineTick.d.ts.map