/**
 * GeoZarr / Zarr raster layer (spec: issue — "Zarr format layers"). A LAZY
 * chunk — dynamically imported the first time a manifest uses
 * `type="ZarrLayer"` (the layer-registry `loadClass` seam), so the eager bundle
 * carries none of zarrita / deck.gl-zarr. Built on
 * `@developmentseed/deck.gl-zarr` (`ZarrLayer`) + `zarrita`, at the same 0.7.0
 * as the COG stack, and it REUSES the shared raster GPU pipeline
 * (raster-pipeline.ts) — colormap / rescale / nodata — that COGLayer uses.
 *
 * GeoZarr is chunked N-dimensional arrays. Two things differ from a COG:
 *  1. The store is opened by US (zarrita FetchStore), not the layer — so this
 *     is a CompositeLayer that opens the store async and renders a child
 *     ZarrLayer once the variable array resolves.
 *  2. It's N-dimensional: the author picks a `variable` and pins every
 *     non-spatial dimension via `select="time=0, level=3"`.
 *
 * Georeferencing: a GeoZarr-compliant store carries the spatial/geo-proj
 * conventions and is used as-is. A plain (non-GeoZarr) store — common for
 * real-world public Zarr, e.g. the ECMWF forecast archive — is georeferenced
 * from author-supplied `bounds` + `crs` + `spatial-dims`, which we assemble
 * into the same synthetic attrs `ZarrLayer`'s `metadata` prop accepts.
 */
import { CompositeLayer, type Layer, type LayersList } from "@deck.gl/core";
import * as zarr from "zarrita";
import { type RasterStyle } from "./raster-pipeline";
type AnyProps = Record<string, unknown>;
/** `select="time=0, level=3"` (or JSON) → the zarrita selection: one pinned index per non-spatial dim. */
export declare function parseZarrSelection(raw: string | undefined): Record<string, number>;
/**
 * Build the synthetic GeoZarr attrs a NON-GeoZarr store needs, from the author's
 * `bounds` + `crs` + `spatial-dims` and the array's own spatial shape (the last
 * two dims). The affine follows @developmentseed/affine's `[a,b,c,d,e,f]` form:
 * `x = a*col + b*row + c`, `y = d*col + e*row + f` — top-left origin.
 */
export declare function buildManualGeoZarrAttrs(bounds: [number, number, number, number], crs: string, spatialDims: [string, string], spatialShape: [number, number]): Record<string, unknown>;
export interface OmZarrLayerProps extends RasterStyle {
    /** The Zarr store URL (a `.zarr` group). */
    src?: string;
    /** Path to the variable array within the store. */
    variable?: string;
    /** Non-spatial dimension pins, `"time=0, level=3"`. Every non-spatial dim must be pinned. */
    select?: string;
    /** Manual georeferencing for a non-GeoZarr store — `[west, south, east, north]`. */
    bounds?: [number, number, number, number];
    /** CRS for manual georeferencing, e.g. `"EPSG:4326"`. Required with `bounds`. */
    crs?: string;
    /** The two spatial dimension names for manual georeferencing, e.g. `"latitude longitude"`. */
    spatialDims?: string;
}
interface ZarrState {
    status: "loading" | "ready" | "error";
    node?: zarr.Array<zarr.NumberDataType, zarr.Readable> | zarr.Group<zarr.Readable>;
    variable?: string;
    metadata?: Record<string, unknown>;
    selection: Record<string, number>;
    loadKey: string;
    /** deck's CompositeLayer state carries an index signature; mirror it so the override type-checks. */
    [key: string]: unknown;
}
/**
 * The manifest-facing class behind `<om-layer type="ZarrLayer">`. Opens the
 * zarrita store, resolves the variable, and renders a child ZarrLayer with our
 * colormap pipeline. Restretch/recolor (min/max/colormap/nodata) never reopen
 * the store — they only rebuild the per-frame render pipeline.
 */
export declare class OmZarrLayer extends CompositeLayer<OmZarrLayerProps & AnyProps> {
    static layerName: string;
    static defaultProps: {
        src: string;
        variable: string;
        select: string;
        rescaleMin: null;
        rescaleMax: null;
        colormap: null;
        nodataOverride: null;
    };
    state: ZarrState;
    initializeState(): void;
    updateState({ changeFlags }: {
        changeFlags: {
            propsChanged: boolean | string;
        };
    }): void;
    private _load;
    renderLayers(): LayersList | Layer | null;
}
export {};