import { type LatLngBoundsLike, type LatLngLike } from "../geo.js";
import { type HeatFieldKernelRequest, type HeatFieldWasmProfile } from "./heat-field-wasm.js";
import { type AsyncBatchOptions } from "./async-batch.js";
export type HeatFieldInput = LatLngLike | [number, number, number?];
export interface HeatFieldOptions {
    cols?: number;
    rows?: number;
    radius?: number;
    blur?: number;
    scaleZoom?: number;
    zoom?: number;
}
export interface HeatFieldGrid {
    grid: Float32Array;
    cols: number;
    rows: number;
    peak: number;
    westMerc: number;
    northMerc: number;
    widthMerc: number;
    heightMerc: number;
    kernelMerc: number;
}
export interface PackedHeatPoints {
    data: Float32Array;
    count: number;
    /** Full source extent in normalized Web Mercator. Kept with the packed snapshot. */
    bounds?: PackedHeatBounds;
}
export interface PackedHeatBounds {
    westMerc: number;
    northMerc: number;
    eastMerc: number;
    southMerc: number;
}
export interface HeatFieldAsyncDataOptions extends AsyncBatchOptions {
}
export type HeatFieldCpuBackend = "js" | "wasm";
export interface HeatFieldCpuResult extends HeatFieldGrid {
    backend: HeatFieldCpuBackend;
    profile?: HeatFieldWasmProfile;
}
export declare function packHeatPoints(points: Iterable<HeatFieldInput>): PackedHeatPoints;
/** Cooperatively project and pack a large heat source, then return one atomic snapshot. */
export declare function packHeatPointsAsync(points: Iterable<HeatFieldInput> | AsyncIterable<HeatFieldInput>, options?: HeatFieldAsyncDataOptions): Promise<PackedHeatPoints>;
/** Convert ObjectManager's compact Float64 `[mercX, mercY]` pack without LatLng objects. */
export declare function packHeatMercator(mercator: Float64Array | Float32Array, pointCount: number, weights?: ArrayLike<number> | null): PackedHeatPoints;
/** Full packed source domain, padded in Mercator units and converted to LatLng bounds. */
export declare function packedHeatLatLngBounds(points: PackedHeatPoints, paddingMerc?: number): LatLngBoundsLike | null;
export declare function createHeatFieldRequest(points: PackedHeatPoints, boundsLike: LatLngBoundsLike, options?: HeatFieldOptions): HeatFieldKernelRequest | null;
export declare function buildHeatFieldCpu(request: HeatFieldKernelRequest, backend?: HeatFieldCpuBackend): HeatFieldCpuResult;
/**
 * The same request with every weight replaced by 1. Applying the kernel to it gives the mass
 * each cell drew from — the denominator of a mean field.
 */
export declare function unitWeightRequest(request: HeatFieldKernelRequest): HeatFieldKernelRequest;
/**
 * Divide a summed field by the mass of the same kernel, turning "how much weight landed here"
 * into "what the weights here average". A summed field cannot tell a hot sparse area from a warm
 * dense one; a mean field can, and its values are in the units of the weights themselves, so a
 * reference maximum is whatever a single point can carry rather than a measured density.
 *
 * `support` guards the sparse tail: where the kernel gathered almost nothing, the quotient is
 * decided by one or two points and would read as a full-strength average in the middle of empty
 * space. Cells below that fraction of the densest cell keep a floor under the divisor, so they
 * fade out instead of flaring up.
 */
export declare function meanHeatField(sum: {
    grid: Float32Array;
    peak: number;
}, mass: {
    grid: Float32Array;
    peak: number;
}, support?: number): {
    grid: Float32Array;
    peak: number;
};
/** Reference implementation; kept for parity tests and environments without WASM. */
export declare function buildHeatFieldJs(request: HeatFieldKernelRequest): {
    grid: Float32Array;
    peak: number;
};
//# sourceMappingURL=heat-field.d.ts.map