webdggrid 1.7.0 → 1.9.0

package/src-ts/webdggrid.ts

@@ -1,6 +1,6 @@
 // @ts-ignore
 import { loadWasm, unloadWasm } from './libdggrid.wasm.js';
-import { Feature, FeatureCollection, GeoJsonProperties, Polygon, Position } from 'geojson';
+import { Feature, FeatureCollection, GeoJSON, GeoJsonProperties, Polygon, Position } from 'geojson';
 
 /**
  * The shape of each cell in the Discrete Global Grid System.
@@ -187,21 +187,31 @@ export interface IDGGSProps {
 
 /**
  * Rewraps a polygon ring that crosses the antimeridian so that all longitudes
- * are in a contiguous range (some may exceed 180°).  This is the format
- * expected by MapLibre GL / Mapbox GL globe projection for antimeridian cells.
- * For renderers that require standard [-180, 180] coordinates, use the raw
- * output from {@link Webdggrid.sequenceNumToGrid} directly.
+ * are in a contiguous range. The output longitudes may fall outside
+ * [-180, 180] — that's intentional, and is the format expected by MapLibre
+ * GL / Mapbox GL globe projection for antimeridian cells. For renderers that
+ * require standard [-180, 180] coordinates, run a final modulo step
+ * downstream.
+ *
+ * Walks consecutive vertices and accumulates a ±360 offset whenever the
+ * longitude delta between neighbours exceeds 180° (the only meaningful sign
+ * of an antimeridian crossing). This keeps the traversal direction faithful
+ * even for polar caps, which span a full 360° in lon and were broken by the
+ * previous "negative-to-positive" rewrite.
  */
 export function unwrapAntimeridianRing(ring: Position[]): Position[] {
-    let minLon = ring[0][0];
-    let maxLon = ring[0][0];
+    if (ring.length === 0) return ring;
+    const out: Position[] = [[ring[0][0], ring[0][1]]];
+    let offset = 0;
     for (let i = 1; i < ring.length; i++) {
-        const lon = ring[i][0];
-        if (lon < minLon) minLon = lon;
-        else if (lon > maxLon) maxLon = lon;
-    }
-    if (maxLon - minLon <= 180) return ring;
-    return ring.map(([lon, lat]) => [lon < 0 ? lon + 360 : lon, lat]);
+        const prev = ring[i - 1][0];
+        const curr = ring[i][0];
+        const delta = curr - prev;
+        if (delta >  180) offset -= 360;
+        else if (delta < -180) offset += 360;
+        out.push([curr + offset, ring[i][1]]);
+    }
+    return out;
 }
 
 const DEFAULT_RESOLUTION = 1;
@@ -778,13 +788,22 @@ export class Webdggrid {
      *   retrieve.
      * @param resolution - Resolution at which the IDs were generated. Defaults
      *   to the instance's current {@link resolution}.
+     * @param unwrap - When `true` (default), antimeridian-crossing rings are
+     *   passed through {@link unwrapAntimeridianRing} so longitudes stay
+     *   contiguous (lons may exceed 180°). Required by MapLibre GL / Mapbox
+     *   GL globe projection. Set to `false` to receive the raw DGGRID output
+     *   in `[-180, 180]` — required by Cesium's `GeoJsonDataSource` (which
+     *   internally normalises lons and breaks polar caps under unwrap), and
+     *   by any sphere-aware renderer that interpolates edges as great-circle
+     *   arcs.
      * @returns A 2-D array: `result[i]` is the vertex ring of `sequenceNum[i]`.
      *   Each vertex is a `[lng, lat]` position.
      * @throws If the WASM module encounters an invalid cell ID.
      */
     sequenceNumToGrid(
         sequenceNum: bigint[],
-        resolution: number = DEFAULT_RESOLUTION
+        resolution: number = DEFAULT_RESOLUTION,
+        unwrap: boolean = true
     ): Position[][] {
         const {
             poleCoordinates: { lat, lng },
@@ -836,7 +855,7 @@ export class Webdggrid {
             for (let j = 0; j < numVertexes; j += 1) {
                 coordinates.push([resultArray[xOffset + j], resultArray[yOffset + j]]);
             }
-            featureSet.push(unwrapAntimeridianRing(coordinates));
+            featureSet.push(unwrap ? unwrapAntimeridianRing(coordinates) : coordinates);
             xOffset += numVertexes;
             yOffset += numVertexes;
         }
@@ -874,15 +893,19 @@ export class Webdggrid {
      * @param sequenceNum - Array of `BigInt` cell IDs to convert.
      * @param resolution - Resolution at which the IDs were generated. Defaults
      *   to the instance's current {@link resolution}.
+     * @param unwrap - Forwarded to {@link sequenceNumToGrid}. Defaults to
+     *   `true` (MapLibre-style unwrap). Pass `false` for Cesium and other
+     *   great-circle-arc renderers.
      * @returns A GeoJSON `FeatureCollection` of `Polygon` features, one per
      *   input cell ID.
      */
     sequenceNumToGridFeatureCollection(
         sequenceNum: bigint[],
-        resolution: number = DEFAULT_RESOLUTION
+        resolution: number = DEFAULT_RESOLUTION,
+        unwrap: boolean = true
     ): FeatureCollection<Polygon, DGGSGeoJsonProperty> {
 
-        const coordinatesArray = this.sequenceNumToGrid(sequenceNum, resolution);
+        const coordinatesArray = this.sequenceNumToGrid(sequenceNum, resolution, unwrap);
 
         const features = coordinatesArray.map((coordinates, index) => {
             const seqNum = sequenceNum[index];
@@ -2370,4 +2393,333 @@ export class Webdggrid {
     // There are no PLANE_to_* transformations available.
     // Use other coordinate systems (GEO, SEQNUM, Q2DI, Q2DD, PROJTRI) as input.
     // -------------------------------------------------------------------------
+
+    // =========================================================================
+    // IGEO7 / Z7 — hexagonal hierarchical index (packed UBIGINT)
+    //
+    // Wraps the upstream Z7 C++ core library (from allixender/igeo7_duckdb).
+    // These are **stateless** bit-level operations on a packed 64-bit index —
+    // they do **not** use the active DGGS configuration and can be called
+    // without first invoking {@link setDggs}.
+    //
+    // Index layout (MSB → LSB):
+    //   [63:60]  base cell  (0-11)
+    //   [59:57]  digit  1   (0-6; 7 = padding / unused slot)
+    //   [56:54]  digit  2
+    //   ...
+    //   [ 2: 0]  digit 20
+    //
+    // The "compact string" form from {@link igeo7ToString} is a 2-digit
+    // zero-padded base cell followed by the non-padding digit characters —
+    // e.g. `'0800432'` (base 08, digits 0,0,4,3,2, resolution 5).
+    //
+    // The invalid sentinel is `UINT64_MAX` (`0xFFFFFFFFFFFFFFFFn`), returned
+    // by {@link igeo7Neighbours} for pentagon-excluded directions and by
+    // {@link igeo7Neighbour} for out-of-range direction arguments.
+    // =========================================================================
+
+    /**
+     * Normalize a 64-bit integer (possibly returned as signed BigInt by the
+     * WASM boundary when bit 63 is set) to its canonical unsigned form.
+     * @internal
+     */
+    private _u64(x: bigint): bigint {
+        return BigInt.asUintN(64, x);
+    }
+
+    /**
+     * Parse a Z7 compact string into a packed 64-bit index.
+     *
+     * ```ts
+     * const idx = dggs.igeo7FromString('0800432');
+     * // idx is a BigInt packed index for base=8, digits=[0,0,4,3,2], res=5
+     * ```
+     *
+     * @param s - Compact Z7 string (2-digit base + digit characters).
+     * @returns Packed index as BigInt (unsigned).
+     */
+    igeo7FromString(s: string): bigint {
+        return this._u64(this._module.igeo7_from_string(s));
+    }
+
+    /**
+     * Render a packed Z7 index as its compact string form.
+     *
+     * Stops at the first padding digit (value 7), producing a string whose
+     * length reflects the cell's resolution (`2 + resolution` characters).
+     *
+     * ```ts
+     * dggs.igeo7ToString(dggs.igeo7FromString('0800432')); // '0800432'
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @returns Compact Z7 string.
+     */
+    igeo7ToString(index: bigint): string {
+        return this._module.igeo7_to_string(index);
+    }
+
+    /**
+     * Pack a base cell and exactly 20 digit slots into a 64-bit Z7 index.
+     *
+     * Use digit value `7` for every slot beyond the desired resolution.
+     * Field values are masked internally — no range-check is required.
+     *
+     * ```ts
+     * // Reconstruct '0800432' — base=8, resolution=5
+     * const idx = dggs.igeo7Encode(
+     *   8, [0,0,4,3,2, 7,7,7,7,7, 7,7,7,7,7, 7,7,7,7,7]
+     * );
+     * // idx === dggs.igeo7FromString('0800432')
+     * ```
+     *
+     * @param base - Base cell (0-11).
+     * @param digits - Exactly 20 digit values (0-7 each).
+     * @returns Packed Z7 index as BigInt.
+     * @throws If `digits.length !== 20`.
+     */
+    igeo7Encode(base: number, digits: number[]): bigint {
+        if (digits.length !== 20) {
+            throw new Error(`igeo7Encode requires exactly 20 digits, got ${digits.length}`);
+        }
+        return this._u64(this._module.igeo7_encode(
+            base,
+            digits[0], digits[1], digits[2], digits[3], digits[4],
+            digits[5], digits[6], digits[7], digits[8], digits[9],
+            digits[10], digits[11], digits[12], digits[13], digits[14],
+            digits[15], digits[16], digits[17], digits[18], digits[19]
+        ));
+    }
+
+    /**
+     * Extract the resolution (0-20) of a packed Z7 index.
+     *
+     * @param index - Packed Z7 index.
+     * @returns Resolution level.
+     */
+    igeo7GetResolution(index: bigint): number {
+        return this._module.igeo7_get_resolution(index);
+    }
+
+    /**
+     * Extract the base cell (0-11) of a packed Z7 index.
+     *
+     * @param index - Packed Z7 index.
+     * @returns Base cell ID.
+     */
+    igeo7GetBaseCell(index: bigint): number {
+        return this._module.igeo7_get_base_cell(index);
+    }
+
+    /**
+     * Extract the `i`-th digit (1-20) of a packed Z7 index.
+     * Positions outside `[1, 20]` return `7` (matches DuckDB extension).
+     *
+     * @param index - Packed Z7 index.
+     * @param position - Digit position, 1-based.
+     * @returns Digit value (0-7).
+     */
+    igeo7GetDigit(index: bigint, position: number): number {
+        return this._module.igeo7_get_digit(index, position);
+    }
+
+    /**
+     * Parent of a Z7 cell — one hierarchy level up.
+     *
+     * At resolution 0 the cell is its own parent (the result has resolution 0
+     * and the same base cell).
+     *
+     * ```ts
+     * const child = dggs.igeo7FromString('0800432');
+     * dggs.igeo7ToString(dggs.igeo7Parent(child)); // '080043'
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @returns Parent index as BigInt.
+     */
+    igeo7Parent(index: bigint): bigint {
+        return this._u64(this._module.igeo7_parent(index));
+    }
+
+    /**
+     * Ancestor of a Z7 cell at a specific resolution.
+     *
+     * Keeps digits `1..resolution` and fills the remainder with padding
+     * (`7`). The argument is clamped to `[0, 20]`.
+     *
+     * ```ts
+     * const cell = dggs.igeo7FromString('0800432');
+     * dggs.igeo7ToString(dggs.igeo7ParentAt(cell, 3)); // '08004'
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @param resolution - Target resolution (0-20).
+     * @returns Ancestor index as BigInt.
+     */
+    igeo7ParentAt(index: bigint, resolution: number): bigint {
+        return this._u64(this._module.igeo7_parent_at(index, resolution));
+    }
+
+    /**
+     * Return all 6 neighbour indices of a Z7 cell, in GBT directions 1-6.
+     *
+     * Invalid neighbours (e.g. one direction on the 12 pentagons) are the
+     * sentinel `UINT64_MAX` (`0xFFFFFFFFFFFFFFFFn`). Use {@link igeo7IsValid}
+     * to filter them out.
+     *
+     * ```ts
+     * const cell = dggs.igeo7FromString('0800432');
+     * const ns = dggs.igeo7Neighbours(cell)
+     *   .filter(n => dggs.igeo7IsValid(n))
+     *   .map(n => dggs.igeo7ToString(n));
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @returns Array of exactly 6 BigInt neighbour indices.
+     */
+    igeo7Neighbours(index: bigint): bigint[] {
+        const raw = this._module.igeo7_get_neighbours(index) as bigint[];
+        return raw.map(n => this._u64(n));
+    }
+
+    /**
+     * Single neighbour of a Z7 cell by GBT direction (1-6).
+     *
+     * Returns the invalid sentinel (`UINT64_MAX`) when `direction` is outside
+     * `[1, 6]` or when the requested neighbour is excluded (pentagons).
+     *
+     * @param index - Packed Z7 index.
+     * @param direction - Direction number, 1-6.
+     * @returns Neighbour index as BigInt.
+     */
+    igeo7Neighbour(index: bigint, direction: number): bigint {
+        return this._u64(this._module.igeo7_get_neighbour(index, direction));
+    }
+
+    /**
+     * Position (1-20) of the first non-zero digit slot in a Z7 index.
+     * Returns `0` when no non-zero digit exists (centre of the base cell).
+     *
+     * @param index - Packed Z7 index.
+     * @returns Position of first non-zero digit, or 0.
+     */
+    igeo7FirstNonZero(index: bigint): number {
+        return this._module.igeo7_first_non_zero(index);
+    }
+
+    /**
+     * Whether a packed Z7 index is valid (i.e. not the `UINT64_MAX` sentinel).
+     *
+     * @param index - Packed Z7 index.
+     * @returns `true` if valid, `false` for the invalid sentinel.
+     */
+    igeo7IsValid(index: bigint): boolean {
+        return this._module.igeo7_is_valid(index);
+    }
+
+    /**
+     * Convert a geodetic latitude (WGS84 ellipsoid) to its authalic latitude
+     * on the equal-area sphere. Implementation follows Karney (2022) — same
+     * polynomial used by the `igeo7_geo_to_authalic` DuckDB scalar function.
+     *
+     * Longitude is unaffected; only latitude is transformed.
+     *
+     * @param latDeg - Geodetic latitude in degrees, range `[-90, 90]`.
+     * @returns Authalic latitude in degrees.
+     */
+    igeo7GeoToAuthalic(latDeg: number): number {
+        return this._module.igeo7_geo_to_authalic(latDeg);
+    }
+
+    /**
+     * Inverse of {@link igeo7GeoToAuthalic} — convert an authalic latitude
+     * back to geodetic.
+     *
+     * @param latDeg - Authalic latitude in degrees.
+     * @returns Geodetic latitude (WGS84) in degrees.
+     */
+    igeo7AuthalicToGeo(latDeg: number): number {
+        return this._module.igeo7_authalic_to_geo(latDeg);
+    }
+
+    /**
+     * Apply {@link igeo7GeoToAuthalic} (or its inverse) to every coordinate of
+     * a GeoJSON geometry, feature, or feature collection. Mirrors the
+     * `igeo7_geo_to_authalic` / `igeo7_authalic_to_geo` DuckDB functions
+     * (which take/return `GEOMETRY`); this is the WASM equivalent for
+     * GeoJSON-shaped inputs.
+     *
+     * The input is **deep-cloned** — the source object is not mutated.
+     * Geometries with `null` or unsupported types are returned unchanged.
+     *
+     * @param input - Any GeoJSON geometry, feature, or feature collection.
+     * @param direction - `'geoToAuthalic'` (default) or `'authalicToGeo'`.
+     * @returns A new GeoJSON object of the same shape with transformed lats.
+     */
+    igeo7TransformGeoJson<T extends GeoJSON>(
+        input: T,
+        direction: 'geoToAuthalic' | 'authalicToGeo' = 'geoToAuthalic',
+    ): T {
+        const fn = direction === 'authalicToGeo'
+            ? (lat: number) => this._module.igeo7_authalic_to_geo(lat)
+            : (lat: number) => this._module.igeo7_geo_to_authalic(lat);
+        return transformGeoJsonLatitudes(input, fn);
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// GeoJSON latitude transform helper (used by igeo7TransformGeoJson)
+// ─────────────────────────────────────────────────────────────────────────────
+
+type Pos = number[];
+
+function transformPos(pos: Pos, fn: (lat: number) => number): Pos {
+    // GeoJSON positions are [lng, lat, ...]; only lat (index 1) is touched,
+    // any z/m values trail through untouched.
+    const out = pos.slice();
+    if (out.length >= 2) out[1] = fn(out[1]);
+    return out;
+}
+
+function transformCoords(coords: any, depth: number, fn: (lat: number) => number): any {
+    if (depth === 0) return transformPos(coords as Pos, fn);
+    return (coords as any[]).map(c => transformCoords(c, depth - 1, fn));
+}
+
+const COORD_DEPTH: Record<string, number> = {
+    Point: 0,
+    LineString: 1,
+    MultiPoint: 1,
+    Polygon: 2,
+    MultiLineString: 2,
+    MultiPolygon: 3,
+};
+
+function transformGeometry(geom: any, fn: (lat: number) => number): any {
+    if (!geom || typeof geom.type !== 'string') return geom;
+    if (geom.type === 'GeometryCollection') {
+        return {
+            ...geom,
+            geometries: (geom.geometries || []).map((g: any) => transformGeometry(g, fn)),
+        };
+    }
+    const depth = COORD_DEPTH[geom.type];
+    if (depth === undefined || !geom.coordinates) return geom;
+    return { ...geom, coordinates: transformCoords(geom.coordinates, depth, fn) };
+}
+
+function transformGeoJsonLatitudes<T>(input: T, fn: (lat: number) => number): T {
+    const node = input as any;
+    if (!node || typeof node.type !== 'string') return input;
+    switch (node.type) {
+        case 'FeatureCollection':
+            return {
+                ...node,
+                features: (node.features || []).map((f: any) => transformGeoJsonLatitudes(f, fn)),
+            } as T;
+        case 'Feature':
+            return { ...node, geometry: transformGeometry(node.geometry, fn) } as T;
+        default:
+            return transformGeometry(node, fn) as T;
+    }
 }

package/types/webdggrid.d.ts

@@ -1,4 +1,4 @@
-import { FeatureCollection, GeoJsonProperties, Polygon, Position } from 'geojson';
+import { FeatureCollection, GeoJSON, GeoJsonProperties, Polygon, Position } from 'geojson';
 /**
  * The shape of each cell in the Discrete Global Grid System.
  *
@@ -178,10 +178,17 @@ export interface IDGGSProps {
 }
 /**
  * Rewraps a polygon ring that crosses the antimeridian so that all longitudes
- * are in a contiguous range (some may exceed 180°).  This is the format
- * expected by MapLibre GL / Mapbox GL globe projection for antimeridian cells.
- * For renderers that require standard [-180, 180] coordinates, use the raw
- * output from {@link Webdggrid.sequenceNumToGrid} directly.
+ * are in a contiguous range. The output longitudes may fall outside
+ * [-180, 180] — that's intentional, and is the format expected by MapLibre
+ * GL / Mapbox GL globe projection for antimeridian cells. For renderers that
+ * require standard [-180, 180] coordinates, run a final modulo step
+ * downstream.
+ *
+ * Walks consecutive vertices and accumulates a ±360 offset whenever the
+ * longitude delta between neighbours exceeds 180° (the only meaningful sign
+ * of an antimeridian crossing). This keeps the traversal direction faithful
+ * even for polar caps, which span a full 360° in lon and were broken by the
+ * previous "negative-to-positive" rewrite.
  */
 export declare function unwrapAntimeridianRing(ring: Position[]): Position[];
 /**
@@ -499,11 +506,19 @@ export declare class Webdggrid {
      *   retrieve.
      * @param resolution - Resolution at which the IDs were generated. Defaults
      *   to the instance's current {@link resolution}.
+     * @param unwrap - When `true` (default), antimeridian-crossing rings are
+     *   passed through {@link unwrapAntimeridianRing} so longitudes stay
+     *   contiguous (lons may exceed 180°). Required by MapLibre GL / Mapbox
+     *   GL globe projection. Set to `false` to receive the raw DGGRID output
+     *   in `[-180, 180]` — required by Cesium's `GeoJsonDataSource` (which
+     *   internally normalises lons and breaks polar caps under unwrap), and
+     *   by any sphere-aware renderer that interpolates edges as great-circle
+     *   arcs.
      * @returns A 2-D array: `result[i]` is the vertex ring of `sequenceNum[i]`.
      *   Each vertex is a `[lng, lat]` position.
      * @throws If the WASM module encounters an invalid cell ID.
      */
-    sequenceNumToGrid(sequenceNum: bigint[], resolution?: number): Position[][];
+    sequenceNumToGrid(sequenceNum: bigint[], resolution?: number, unwrap?: boolean): Position[][];
     /**
      * Converts an array of DGGS cell IDs into a GeoJSON `FeatureCollection`
      * where each `Feature` is a `Polygon` representing the cell boundary.
@@ -534,10 +549,13 @@ export declare class Webdggrid {
      * @param sequenceNum - Array of `BigInt` cell IDs to convert.
      * @param resolution - Resolution at which the IDs were generated. Defaults
      *   to the instance's current {@link resolution}.
+     * @param unwrap - Forwarded to {@link sequenceNumToGrid}. Defaults to
+     *   `true` (MapLibre-style unwrap). Pass `false` for Cesium and other
+     *   great-circle-arc renderers.
      * @returns A GeoJSON `FeatureCollection` of `Polygon` features, one per
      *   input cell ID.
      */
-    sequenceNumToGridFeatureCollection(sequenceNum: bigint[], resolution?: number): FeatureCollection<Polygon, DGGSGeoJsonProperty>;
+    sequenceNumToGridFeatureCollection(sequenceNum: bigint[], resolution?: number, unwrap?: boolean): FeatureCollection<Polygon, DGGSGeoJsonProperty>;
     /**
      * Returns all neighboring cells (sharing an edge) for each input cell.
      *
@@ -1292,5 +1310,189 @@ export declare class Webdggrid {
         i: bigint;
         j: bigint;
     }>;
+    /**
+     * Normalize a 64-bit integer (possibly returned as signed BigInt by the
+     * WASM boundary when bit 63 is set) to its canonical unsigned form.
+     * @internal
+     */
+    private _u64;
+    /**
+     * Parse a Z7 compact string into a packed 64-bit index.
+     *
+     * ```ts
+     * const idx = dggs.igeo7FromString('0800432');
+     * // idx is a BigInt packed index for base=8, digits=[0,0,4,3,2], res=5
+     * ```
+     *
+     * @param s - Compact Z7 string (2-digit base + digit characters).
+     * @returns Packed index as BigInt (unsigned).
+     */
+    igeo7FromString(s: string): bigint;
+    /**
+     * Render a packed Z7 index as its compact string form.
+     *
+     * Stops at the first padding digit (value 7), producing a string whose
+     * length reflects the cell's resolution (`2 + resolution` characters).
+     *
+     * ```ts
+     * dggs.igeo7ToString(dggs.igeo7FromString('0800432')); // '0800432'
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @returns Compact Z7 string.
+     */
+    igeo7ToString(index: bigint): string;
+    /**
+     * Pack a base cell and exactly 20 digit slots into a 64-bit Z7 index.
+     *
+     * Use digit value `7` for every slot beyond the desired resolution.
+     * Field values are masked internally — no range-check is required.
+     *
+     * ```ts
+     * // Reconstruct '0800432' — base=8, resolution=5
+     * const idx = dggs.igeo7Encode(
+     *   8, [0,0,4,3,2, 7,7,7,7,7, 7,7,7,7,7, 7,7,7,7,7]
+     * );
+     * // idx === dggs.igeo7FromString('0800432')
+     * ```
+     *
+     * @param base - Base cell (0-11).
+     * @param digits - Exactly 20 digit values (0-7 each).
+     * @returns Packed Z7 index as BigInt.
+     * @throws If `digits.length !== 20`.
+     */
+    igeo7Encode(base: number, digits: number[]): bigint;
+    /**
+     * Extract the resolution (0-20) of a packed Z7 index.
+     *
+     * @param index - Packed Z7 index.
+     * @returns Resolution level.
+     */
+    igeo7GetResolution(index: bigint): number;
+    /**
+     * Extract the base cell (0-11) of a packed Z7 index.
+     *
+     * @param index - Packed Z7 index.
+     * @returns Base cell ID.
+     */
+    igeo7GetBaseCell(index: bigint): number;
+    /**
+     * Extract the `i`-th digit (1-20) of a packed Z7 index.
+     * Positions outside `[1, 20]` return `7` (matches DuckDB extension).
+     *
+     * @param index - Packed Z7 index.
+     * @param position - Digit position, 1-based.
+     * @returns Digit value (0-7).
+     */
+    igeo7GetDigit(index: bigint, position: number): number;
+    /**
+     * Parent of a Z7 cell — one hierarchy level up.
+     *
+     * At resolution 0 the cell is its own parent (the result has resolution 0
+     * and the same base cell).
+     *
+     * ```ts
+     * const child = dggs.igeo7FromString('0800432');
+     * dggs.igeo7ToString(dggs.igeo7Parent(child)); // '080043'
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @returns Parent index as BigInt.
+     */
+    igeo7Parent(index: bigint): bigint;
+    /**
+     * Ancestor of a Z7 cell at a specific resolution.
+     *
+     * Keeps digits `1..resolution` and fills the remainder with padding
+     * (`7`). The argument is clamped to `[0, 20]`.
+     *
+     * ```ts
+     * const cell = dggs.igeo7FromString('0800432');
+     * dggs.igeo7ToString(dggs.igeo7ParentAt(cell, 3)); // '08004'
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @param resolution - Target resolution (0-20).
+     * @returns Ancestor index as BigInt.
+     */
+    igeo7ParentAt(index: bigint, resolution: number): bigint;
+    /**
+     * Return all 6 neighbour indices of a Z7 cell, in GBT directions 1-6.
+     *
+     * Invalid neighbours (e.g. one direction on the 12 pentagons) are the
+     * sentinel `UINT64_MAX` (`0xFFFFFFFFFFFFFFFFn`). Use {@link igeo7IsValid}
+     * to filter them out.
+     *
+     * ```ts
+     * const cell = dggs.igeo7FromString('0800432');
+     * const ns = dggs.igeo7Neighbours(cell)
+     *   .filter(n => dggs.igeo7IsValid(n))
+     *   .map(n => dggs.igeo7ToString(n));
+     * ```
+     *
+     * @param index - Packed Z7 index.
+     * @returns Array of exactly 6 BigInt neighbour indices.
+     */
+    igeo7Neighbours(index: bigint): bigint[];
+    /**
+     * Single neighbour of a Z7 cell by GBT direction (1-6).
+     *
+     * Returns the invalid sentinel (`UINT64_MAX`) when `direction` is outside
+     * `[1, 6]` or when the requested neighbour is excluded (pentagons).
+     *
+     * @param index - Packed Z7 index.
+     * @param direction - Direction number, 1-6.
+     * @returns Neighbour index as BigInt.
+     */
+    igeo7Neighbour(index: bigint, direction: number): bigint;
+    /**
+     * Position (1-20) of the first non-zero digit slot in a Z7 index.
+     * Returns `0` when no non-zero digit exists (centre of the base cell).
+     *
+     * @param index - Packed Z7 index.
+     * @returns Position of first non-zero digit, or 0.
+     */
+    igeo7FirstNonZero(index: bigint): number;
+    /**
+     * Whether a packed Z7 index is valid (i.e. not the `UINT64_MAX` sentinel).
+     *
+     * @param index - Packed Z7 index.
+     * @returns `true` if valid, `false` for the invalid sentinel.
+     */
+    igeo7IsValid(index: bigint): boolean;
+    /**
+     * Convert a geodetic latitude (WGS84 ellipsoid) to its authalic latitude
+     * on the equal-area sphere. Implementation follows Karney (2022) — same
+     * polynomial used by the `igeo7_geo_to_authalic` DuckDB scalar function.
+     *
+     * Longitude is unaffected; only latitude is transformed.
+     *
+     * @param latDeg - Geodetic latitude in degrees, range `[-90, 90]`.
+     * @returns Authalic latitude in degrees.
+     */
+    igeo7GeoToAuthalic(latDeg: number): number;
+    /**
+     * Inverse of {@link igeo7GeoToAuthalic} — convert an authalic latitude
+     * back to geodetic.
+     *
+     * @param latDeg - Authalic latitude in degrees.
+     * @returns Geodetic latitude (WGS84) in degrees.
+     */
+    igeo7AuthalicToGeo(latDeg: number): number;
+    /**
+     * Apply {@link igeo7GeoToAuthalic} (or its inverse) to every coordinate of
+     * a GeoJSON geometry, feature, or feature collection. Mirrors the
+     * `igeo7_geo_to_authalic` / `igeo7_authalic_to_geo` DuckDB functions
+     * (which take/return `GEOMETRY`); this is the WASM equivalent for
+     * GeoJSON-shaped inputs.
+     *
+     * The input is **deep-cloned** — the source object is not mutated.
+     * Geometries with `null` or unsupported types are returned unchanged.
+     *
+     * @param input - Any GeoJSON geometry, feature, or feature collection.
+     * @param direction - `'geoToAuthalic'` (default) or `'authalicToGeo'`.
+     * @returns A new GeoJSON object of the same shape with transformed lats.
+     */
+    igeo7TransformGeoJson<T extends GeoJSON>(input: T, direction?: 'geoToAuthalic' | 'authalicToGeo'): T;
 }
 //# sourceMappingURL=webdggrid.d.ts.map