import { type Point } from "../geo.js";
import { InteractiveLayer } from "../interactive-layer.js";
import { type LayerOptions, type QueryHit, type ResolvedQueryOptions } from "../layer.js";
import type { Orihon } from "../map.js";
import type { OverlayContent, PopupOptions, TooltipOptions } from "../overlays/div-overlay.js";
import { type HeatFieldAsyncDataOptions } from "../services/heat-field.js";
import { type HeatBackend, type HeatMode, type HeatEvaluation, type HeatContour, type HeatGrid, type HeatOptions, type HeatPoint, type HeatProfile } from "../services/heat.js";
/**
 * Colour stops keyed by field value. Keys at or below 1 are fractions of `referenceMax`, or of
 * the current grid peak when none is set; keys above 1 are absolute field values and need
 * `referenceMax` to be positioned — the same convention `levels` uses.
 */
export type HeatGradient = Record<number, string>;
export interface HeatAsyncDataOptions extends HeatFieldAsyncDataOptions {
}
export interface HeatLayerOptions extends LayerOptions, HeatOptions {
    /** `static`: one full-dataset field; `zoom`: refine the field at each settled zoom. */
    evaluation?: HeatEvaluation;
    labels?: boolean;
    /** Absolute contour interval, or `"auto"` for a stable engineering step. */
    step?: "auto" | number;
    /** Fill contour zones from the same scalar grid in isolines-only mode. Default true. */
    bands?: boolean;
    /** Keep the complete evaluation domain in the lowest zone. Default true. */
    cover?: boolean;
    gradient?: HeatGradient;
    opacity?: number;
    minOpacity?: number;
    domainOpacity?: number;
    /** Fractional padding around the full source extent in static mode. Default 0.035. */
    domainPadding?: number;
    dynamic?: boolean;
    /** Run field + contour computation off the main thread when Worker is available. Default true. */
    worker?: boolean;
    pad?: number;
    isolineWidth?: number;
    isolineOpacity?: number;
    isolineLabelFormat?: (ring: HeatContour) => string;
    isolineLabelFont?: string;
    isolineLabelColor?: string | "auto";
    isolineLabelMinVertices?: number;
    /** Enable line/zone hover, click, query, popup and tooltip interaction. */
    interactive?: boolean;
    /** Extra screen-pixel tolerance for isoline hit testing. Default 6. */
    hitTolerance?: number;
    /** Redraw the hovered line or zone boundaries. Default true. */
    hoverHighlight?: boolean;
    /** Keep the clicked line or zone selected. Default true. */
    selectOnClick?: boolean;
    highlightColor?: string;
    selectionColor?: string;
    highlightWidth?: number;
}
export interface HeatFeature {
    kind: "line" | "zone";
    /** Bilinearly sampled scalar-field value at the pointer. */
    fieldValue: number;
    /** Exact contour value for a line; sampled field value for a zone. */
    value: number;
    /** Normalized field value against referenceMax/current peak. */
    t: number;
    /** Inclusive lower boundary of a zone. */
    lowerValue: number;
    /** Exclusive upper boundary; null for the topmost zone. */
    upperValue: number | null;
    /** Zone index or contour level index. */
    levelId: number;
    /** Present for line hits. */
    ringIndex?: number;
    ring?: HeatContour;
}
interface ResolvedHeatLayerOptions extends LayerOptions, HeatOptions {
    mode: HeatMode;
    backend: HeatBackend;
    evaluation: HeatEvaluation;
    labels: boolean;
    step: "auto" | number;
    bands: boolean;
    cover: boolean;
    gradient: HeatGradient;
    opacity: number;
    minOpacity: number;
    domainOpacity: number;
    domainPadding: number;
    dynamic: boolean;
    worker: boolean;
    pad: number;
    isolineWidth: number;
    isolineOpacity: number;
    isolineLabelFormat: (ring: HeatContour) => string;
    isolineLabelFont: string;
    isolineLabelColor: string | "auto";
    isolineLabelMinVertices: number;
    interactive: boolean;
    hitTolerance: number;
    hoverHighlight: boolean;
    selectOnClick: boolean;
    highlightColor: string;
    selectionColor: string;
    highlightWidth: number;
}
export interface HeatLayerStats extends HeatProfile {
    rings: number;
    peak: number;
    renderMs: number;
    worker: boolean;
}
export interface HeatPointerDetail {
    originalEvent: MouseEvent | PointerEvent;
    latlng: ReturnType<Orihon["containerPointToLatLng"]>;
    containerPoint: {
        x: number;
        y: number;
    };
    data: HeatFeature;
    feature: HeatFeature;
    index: number;
}
export interface HeatEventMap {
    select: {
        data: HeatFeature;
        feature: HeatFeature;
    };
    unselect: {
        data: HeatFeature;
        feature: HeatFeature;
    };
    rebuild: {
        stats: HeatLayerStats;
    };
    click: HeatPointerDetail;
    contextmenu: HeatPointerDetail;
    mouseover: {
        originalEvent: MouseEvent;
        latlng: ReturnType<Orihon["containerPointToLatLng"]>;
        data: HeatFeature;
        feature: HeatFeature;
    };
    mousemove: HeatEventMap["mouseover"];
    mouseout: {
        originalEvent: MouseEvent;
        latlng: ReturnType<Orihon["containerPointToLatLng"]> | null;
        data: HeatFeature;
        feature: HeatFeature;
    };
    hover: {
        originalEvent: MouseEvent;
        latlng: ReturnType<Orihon["containerPointToLatLng"]> | null;
        containerPoint: {
            x: number;
            y: number;
        } | null;
        data: HeatFeature | null;
        feature: HeatFeature | null;
    };
}
/** One field, three views: continuous heat colors, isolines, or both. */
export declare class HeatLayer extends InteractiveLayer<ResolvedHeatLayerOptions, HeatEventMap> {
    #private;
    canvas: HTMLCanvasElement | null;
    private _fieldCanvas;
    private _points;
    private _field;
    private _rings;
    private _thresholds;
    private _profile;
    private _renderMs;
    private _palette;
    private _resolvedScaleZoom;
    private _buildPromise;
    private _rebuildQueued;
    private _generation;
    private _worker;
    private _workerDisabled;
    private _workerRevision;
    private _workerSyncedRevision;
    private _workerRequestId;
    private _workerPending;
    private _workerReady;
    private _resolveWorkerReady;
    private _usedWorker;
    private _paintedZoom;
    private _paintedOriginX;
    private _paintedOriginY;
    private _paintedPad;
    private _screenRings;
    private _hoverFeature;
    private _selectedFeature;
    private _interactionUnsub;
    private readonly _onMove;
    private readonly _onSettle;
    constructor(points?: Iterable<HeatPoint>, options?: HeatLayerOptions);
    get count(): number;
    getStats(): HeatLayerStats;
    getField(): HeatGrid | null;
    getIsolines(): HeatContour[];
    setData(points: Iterable<HeatPoint>): this;
    setLatLngs(points: Iterable<HeatPoint>): this;
    /** Project a large source cooperatively and swap the packed field input atomically. */
    setDataAsync(points: Iterable<HeatPoint> | AsyncIterable<HeatPoint>, options?: HeatAsyncDataOptions): Promise<this>;
    setPackedMercator(mercator: Float64Array | Float32Array, pointCount: number, weights?: ArrayLike<number> | null): this;
    clear(): this;
    setMode(mode: HeatMode): this;
    setBackend(backend: HeatBackend): this;
    setEvaluation(evaluation: HeatEvaluation): this;
    setLabels(enabled: boolean): this;
    bindPopup(content: OverlayContent, options?: PopupOptions): this;
    bindTooltip(content: OverlayContent, options?: TooltipOptions): this;
    setInteractive(enabled: boolean): this;
    getHoveredFeature(): HeatFeature | null;
    getSelectedFeature(): HeatFeature | null;
    selectFeature(feature: HeatFeature | null): this;
    clearSelection(): this;
    /** Identify a contour line first, otherwise the scalar zone at a map point. */
    getFeatureAt(target: Point, tolerance?: number): HeatFeature | null;
    queryHit(target: Point, options: ResolvedQueryOptions): QueryHit | null;
    setGradient(gradient: HeatGradient): this;
    rebuild(): this;
    rebuildAsync(): Promise<this>;
    onAdd(map: Orihon): void;
    onRemove(): void;
    wantsFrameRender(): boolean;
    render(): void;
}
export declare function heatLayer(points?: Iterable<HeatPoint>, options?: HeatLayerOptions): HeatLayer;
export {};
//# sourceMappingURL=heat.d.ts.map