import { type LatLngLike, 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 } from "../overlays/div-overlay.js";
import { type AsyncBatchOptions } from "../services/async-batch.js";
import { type RgbColor } from "../webgl-utils.js";
export type WebGLPointInput = LatLngLike | {
    coordinates?: LatLngLike;
    latlng?: LatLngLike;
    lat?: number;
    lng?: number;
};
export interface WebGLPointDataOptions {
    /** Interleaved RGBA floats in 0..1, length = pointCount * 4. */
    colors?: ArrayLike<number> | null;
    /** Per-point sizes in CSS pixels, length = pointCount. */
    sizes?: ArrayLike<number> | null;
    /**
     * Take ownership of `latlng` / `merc64` typed arrays (no copy).
     * Callers must not reuse those buffers after `setPackedData`.
     */
    adopt?: boolean;
}
export interface WebGLPointAsyncDataOptions extends WebGLPointDataOptions, AsyncBatchOptions {
}
export interface WebGLPointLayerOptions extends LayerOptions {
    pointSize?: number;
    color?: string;
    opacity?: number;
    maxDpr?: number;
    fallbackCanvas?: boolean;
    rotation?: number;
    pitch?: number;
    interactive?: boolean;
    hitTolerance?: number;
    /** When true, canvas fallback still CPU-culls. WebGL always transforms on GPU. */
    cull?: boolean;
}
type ResolvedWebGLPointLayerOptions = Required<WebGLPointLayerOptions>;
export interface WebGLPointLayerStats {
    points: number;
    rendered: number;
    renderer: "webgl" | "canvas" | "none";
    bufferBytes: number;
    vertexColors: boolean;
    vertexSizes: boolean;
    /** Spatial pick-index size; 0 when `interactive` is false. */
    pickIndex: number;
}
export interface WebGLPointEventMap {
    click: {
        originalEvent: MouseEvent | PointerEvent;
        latlng: LatLngLike;
        containerPoint: {
            x: number;
            y: number;
        };
        index: number;
        data: WebGLPointInput | undefined;
    };
    hover: {
        originalEvent: MouseEvent;
        latlng: LatLngLike | null;
        containerPoint: {
            x: number;
            y: number;
        } | null;
        index: number;
        data: WebGLPointInput | null | undefined;
    };
}
export declare class WebGLPointLayer extends InteractiveLayer<ResolvedWebGLPointLayerOptions, WebGLPointEventMap> {
    #private;
    canvas: HTMLCanvasElement | null;
    gl: WebGLRenderingContext | null;
    program: WebGLProgram | null;
    buffer: WebGLBuffer | null;
    colorBuffer: WebGLBuffer | null;
    sizeBuffer: WebGLBuffer | null;
    /** Packed lat/lng pairs for hit-testing and canvas fallback. */
    points: Float32Array;
    /**
     * GPU upload buffer: mercator relative to the current camera ref (float32).
     * Absolute world mercator lives in `_merc64` (float64) to avoid high-zoom collapse.
     */
    mercator: Float32Array;
    /** Interleaved RGBA bytes (0..255) when per-point colors are enabled. */
    colors: Uint8Array;
    /** Per-point sizes in CSS pixels when vertex sizes are enabled. */
    sizes: Float32Array;
    pointData: WebGLPointInput[];
    renderer: "webgl" | "canvas" | "none";
    readonly color: RgbColor;
    private _interactionUnsub;
    private _lastRendered;
    private _glLocations;
    private _bufferDirty;
    private _colorDirty;
    private _sizeDirty;
    private _useVertexColor;
    private _useVertexSize;
    private _scratch;
    private _scratchColors;
    private _latlngBuf;
    private _merc64;
    private _drawMerc;
    private _colorBuf;
    private _colorFloat;
    private _sizeBuf;
    /** Reused sorted GPU-slot scratch for batched style updates. */
    private _stylePatchIndexScratch;
    private _gpuMercBytes;
    private _gpuColorBytes;
    private _gpuSizeBytes;
    private _refMx;
    private _refMy;
    private _refZoom;
    private _refOriginX;
    private _refOriginY;
    private _pickIndex;
    private _maxVertexSize;
    /** True when `_latlngBuf` / `_merc64` were adopted from the caller (may be shared). */
    private _packedAdopted;
    private _hidden;
    private _forceGpu;
    private _hasPainted;
    private _paintedZoom;
    private _paintedOriginX;
    private _paintedOriginY;
    private _paintedPad;
    private _lastGpuMs;
    private _settleTimer;
    constructor(points?: Iterable<WebGLPointInput>, options?: WebGLPointLayerOptions);
    onAdd(map: Orihon): void;
    onRemove(): void;
    setData(points: Iterable<WebGLPointInput>, options?: WebGLPointDataOptions): this;
    /**
     * Project and pack a large point iterable across bounded main-thread tasks,
     * then replace the live GPU dataset atomically.
     */
    setDataAsync(points: Iterable<WebGLPointInput> | AsyncIterable<WebGLPointInput>, options?: WebGLPointAsyncDataOptions): Promise<this>;
    /** Replace per-point RGBA (0..1). Pass null to fall back to uniform `color`. */
    setColors(colors: ArrayLike<number> | null): this;
    /** Replace per-point sizes in CSS pixels. Pass null to fall back to uniform `pointSize`. */
    setSizes(sizes: ArrayLike<number> | null): this;
    /**
     * Patch a single point in place (no full re-encode). Used by ObjectManager live updates.
     */
    patchPoint(index: number, lat: number, lng: number): this;
    /** Patch one vertex RGBA (0..1) without rebuilding the full color buffer. */
    patchColor(index: number, rgba: ArrayLike<number>): this;
    /** Patch one vertex size without rebuilding coordinates or color buffers. */
    patchSize(index: number, size: number): this;
    /**
     * Patch many vertex colors/sizes in one pass. GPU writes are merged into
     * contiguous ranges and large/fragmented batches fall back to one full upload.
     */
    patchStyles(indices: ArrayLike<number>, colors?: ArrayLike<number> | null, sizes?: ArrayLike<number> | null, count?: number): this;
    /**
     * Load precomputed lat/lng + absolute mercator buffers (skips normalize + merc encode).
     * Used by ObjectManager filter restore / compact paths at 100k–1M.
     */
    setPackedData(latlng: Float32Array, merc64: Float64Array, options?: WebGLPointDataOptions): this;
    /** Absolute float64 mercator pairs (same length as `points`). */
    getMercator64(): Float64Array;
    getLatLngBuf(): Float32Array;
    /** Interleaved RGBA floats in 0..1 (converted from the packed GPU bytes). */
    getColorBuf(): Float32Array;
    getSizeBuf(): Float32Array;
    addData(points: Iterable<WebGLPointInput>): this;
    clear(): this;
    bindPopup(content: OverlayContent, options?: PopupOptions): this;
    setInteractive(enabled: boolean): this;
    setViewTransform(options: {
        rotation?: number;
        pitch?: number;
    }): this;
    /** Public hit-test for ObjectManager hover / bench sampling. */
    hitTestAt(clientX: number, clientY: number, tolerance?: number): {
        index: number;
        latlng: LatLngLike;
        containerPoint: {
            x: number;
            y: number;
        };
    } | null;
    queryHit(point: Point, options: ResolvedQueryOptions): QueryHit | null;
    getStats(): WebGLPointLayerStats;
    /** Hide the canvas without dropping GPU buffers (heatmap / cluster overlays). */
    setHidden(hidden: boolean): this;
    wantsFrameRender(): boolean;
    render(): void;
}
export declare function webglPointLayer(points?: Iterable<WebGLPointInput>, options?: WebGLPointLayerOptions): WebGLPointLayer;
export {};
//# sourceMappingURL=webgl-point-layer.d.ts.map