import { LatLngBounds, type LatLngBoundsLike } from "../geo.js";
import type { RasterTileLayer } from "../layers/tile-layer.js";
/** Where a single prefetch URL was lost. */
export type OfflineTileFailureStage = 
/** Rejected by `urlPrefixes` or by the scheme allowlist before any request was made. */
"url"
/** The request itself failed (network, CORS, abort). */
 | "fetch"
/** The response arrived but Cache Storage refused it (quota, opaque limits). */
 | "cache";
export interface OfflineTileFailure {
    url: string;
    stage: OfflineTileFailureStage;
    /** The thrown value, or `undefined` when the URL never left the allowlist check. */
    cause?: unknown;
}
export interface OfflineTileCacheOptions {
    cacheName?: string;
    fetcher?: typeof fetch;
    maxTiles?: number;
    /** Maximum simultaneous network requests. Clamped to 1..32; default 8. */
    concurrency?: number;
    /** Same allowlist as the Service Worker. Empty = app-owned explicit URLs, still rejects javascript/data/blob/file. */
    urlPrefixes?: string[];
    /**
     * Called once per lost tile with the URL, the stage and the original cause. `stats.failed`
     * alone cannot tell a blocked prefix from a quota error, and for offline work the failures
     * are the interesting half. A throwing callback never aborts the prefetch.
     */
    onError?: (failure: OfflineTileFailure) => void;
}
export interface OfflineTileCacheStats {
    cacheName: string;
    supported: boolean;
    queued: number;
    cached: number;
    failed: number;
}
export interface OfflineServiceWorkerOptions {
    cacheName?: string;
    scope?: string;
    path?: string;
    /** Only these URL prefixes are network-cached. Empty = serve cache hits only, never cache new GETs. */
    urlPrefixes?: string[];
}
/**
 * Prefetch only needs a tile URL scheme. `tileLayer()` returns the `RasterTileLayer` contract,
 * which the concrete `TileLayer` and `GPUTileLayer` both satisfy; requiring the class here made
 * the two public functions impossible to combine without a cast.
 */
export type PrefetchableTileLayer = Pick<RasterTileLayer, "getTileUrl"> & {
    getTileSize?: () => number;
};
interface PrefetchTileLayerBaseOptions {
    zooms: number[];
    maxTiles?: number;
}
export type PrefetchTileLayerOptions = PrefetchTileLayerBaseOptions & ({
    bounds: LatLngBoundsLike;
    /** Optional override for the X range derived from bounds. */
    xRange?: [number, number];
    /** Optional override for the Y range derived from bounds. */
    yRange?: [number, number];
} | {
    bounds?: never;
    xRange: [number, number];
    yRange: [number, number];
});
export declare class OfflineTileCache {
    #private;
    readonly cacheName: string;
    readonly fetcher: typeof fetch;
    readonly maxTiles: number;
    readonly concurrency: number;
    readonly urlPrefixes: string[];
    queued: number;
    cached: number;
    failed: number;
    constructor(options?: OfflineTileCacheOptions);
    get supported(): boolean;
    getStats(): OfflineTileCacheStats;
    prefetch(urls: Iterable<string>): Promise<OfflineTileCacheStats>;
    prefetchTileLayer(layer: PrefetchableTileLayer, options: PrefetchTileLayerOptions): Promise<OfflineTileCacheStats>;
    match(url: string): Promise<Response | undefined>;
    clear(): Promise<void>;
    createServiceWorkerScript(options?: OfflineServiceWorkerOptions): string;
    registerServiceWorker(options?: OfflineServiceWorkerOptions): Promise<ServiceWorkerRegistration | null>;
}
export declare function offlineTileCache(options?: OfflineTileCacheOptions): OfflineTileCache;
export declare function prefetchUrlAllowed(url: string, prefixes?: readonly string[]): boolean;
export declare function tileRangeForBounds(bounds: LatLngBounds, zoom: number, tileSize?: number): {
    xRange: [number, number];
    yRange: [number, number];
};
export {};
//# sourceMappingURL=offline-cache.d.ts.map