import { OrihonError } from "../errors.js";
import { type LatLngLike } from "../geo.js";
import { type ClusterIndex, type ClusterLayoutRequest, type ClusterLayoutResult } from "./cluster-layout.js";
import { type AsyncBatchOptions } from "./async-batch.js";
export type GeometryPointInput = LatLngLike | {
    coordinates?: LatLngLike;
    latlng?: LatLngLike;
    lat?: number;
    lng?: number;
};
export interface PreparedPointBatch {
    points: Float32Array;
    count: number;
    skipped: number;
}
export interface GeometryWorkerOptions {
    useWorker?: boolean;
}
export interface ClusterWasmWorkerStats {
    attempts: number;
    successes: number;
    fallbacks: number;
    recycledWorkers: number;
    datasetInstalls: number;
    datasetReuses: number;
    datasetMisses: number;
    datasetBytesTransferred: number;
    avoidedCoordTransferBytes: number;
    lastDatasetBytes: number;
    lastWasmMemoryBytes: number;
    lastOutputBytes: number;
    lastScratchBytes: number;
}
export interface GeometryPrepareOptions extends AsyncBatchOptions {
}
type ClusterDatasetTagged = {
    __datasetVersion?: number;
};
type ClusterGreedyWorkerRequest = ClusterLayoutRequest & ClusterDatasetTagged;
type ClusterIndexWorkerRequest = Omit<ClusterLayoutRequest, "zoomBucket"> & ClusterDatasetTagged;
type PendingResolve = ({
    type: "preparePoints";
    resolve: (value: PreparedPointBatch) => void;
} | {
    type: "clusterLayout";
    resolve: (value: ClusterLayoutResult) => void;
} | {
    type: "clusterDatasetInstall";
    datasetId: number;
    resolve: (ok: boolean) => void;
} | {
    type: "greedyClusterLayout";
    request: ClusterGreedyWorkerRequest;
    resolve: (value: ClusterLayoutResult) => void;
} | {
    type: "clusterIndex";
    request: ClusterIndexWorkerRequest;
    resolve: (value: ClusterIndex) => void;
}) & {
    reject: (reason?: unknown) => void;
};
export declare class GeometryWorkerError extends OrihonError {
    constructor(message: string, options?: ErrorOptions);
}
export declare class GeometryWorkerPool {
    #private;
    readonly useWorker: boolean;
    worker: Worker | null;
    workerUrl: string | null;
    readonly pending: Map<number, PendingResolve>;
    readonly clusterIndexIds: Map<number, import("./cluster-layout.js").ClusterLayoutId[]>;
    readonly clusterWasmStats: ClusterWasmWorkerStats;
    private _recycleWorkerWhenIdle;
    private _workerEpoch;
    private _nextClusterDatasetId;
    private _clusterDataset;
    private _clusterDatasetInstallKey;
    private _clusterDatasetInstallPromise;
    private _destroyed;
    constructor(options?: GeometryWorkerOptions);
    preparePoints(points: Iterable<GeometryPointInput> | AsyncIterable<GeometryPointInput>, options?: GeometryPrepareOptions): Promise<PreparedPointBatch>;
    clusterLayout(request: ClusterLayoutRequest): Promise<ClusterLayoutResult>;
    /** Build one zoom in a worker without cloning arbitrary ids or retransferring persistent coords. */
    greedyClusterLayout(request: ClusterGreedyWorkerRequest): Promise<ClusterLayoutResult>;
    /** Build transferable hierarchical index once; persistent worker dataset avoids repeated coord copies. */
    clusterIndex(request: ClusterIndexWorkerRequest): Promise<ClusterIndex>;
    getClusterWasmStats(): Readonly<ClusterWasmWorkerStats>;
    destroy(): void;
}
/** Creates a caller-owned pool. The caller must eventually call destroy(). */
export declare function createGeometryWorkerPool(options?: GeometryWorkerOptions): GeometryWorkerPool;
/**
 * @internal Shared infrastructure for library-managed services. Does not take a
 * reference — use {@link acquireSharedGeometryWorkerPool} for anything with a
 * lifecycle, so the worker and its installed coordinate dataset can be released.
 */
export declare function getSharedGeometryWorkerPool(): GeometryWorkerPool;
/**
 * @internal Takes a reference to the shared pool. Every call must be paired with
 * {@link releaseSharedGeometryWorkerPool}; the worker thread and its transferred
 * coordinate dataset are torn down once the last holder releases it.
 */
export declare function acquireSharedGeometryWorkerPool(): GeometryWorkerPool;
/** @internal Releases one reference; terminates the worker when none remain. */
export declare function releaseSharedGeometryWorkerPool(pool: GeometryWorkerPool): void;
export declare function preparePointBatch(points: Iterable<GeometryPointInput>): PreparedPointBatch;
/** Cooperative main-thread fallback for environments where Worker is unavailable or disabled. */
export declare function preparePointBatchAsync(points: Iterable<GeometryPointInput> | AsyncIterable<GeometryPointInput>, options?: GeometryPrepareOptions): Promise<PreparedPointBatch>;
export {};
//# sourceMappingURL=geometry-worker.d.ts.map