nodes2ts 3.0.0 → 4.0.1

package/dist/export.d.ts

@@ -1,23 +1,1838 @@
-import { S2Region } from "./S2Region";
-import { S2LatLng } from "./S2LatLng";
-export * from './Interval';
-export * from './MutableInteger';
-export * from './R1Interval';
-export * from './R2Vector';
-export * from './S1Angle';
-export * from './S1Interval';
-export * from './S2';
-export * from './S2Cap';
-export * from './S2Cell';
-export * from './S2CellId';
-export * from './S2CellUnion';
-export * from './S2LatLng';
-export * from './S2LatLngRect';
-export * from './S2Point';
-export * from './S2Projections';
-export * from './S2Region';
-export * from './S2RegionCoverer';
-export declare class Utils {
+declare abstract class Interval {
+    lo: number;
+    hi: number;
+    constructor(lo: number, hi: number);
+    /** Return true if the interval is empty, i.e. it contains no points. */
+    abstract isEmpty(): boolean;
+    /**
+     * Return the center of the interval. For empty intervals, the result is
+     * arbitrary.
+     */
+    abstract getCenter(): number;
+    /**
+     * Return the length of the interval. The length of an empty interval is
+     * negative.
+     */
+    abstract getLength(): number;
+    abstract contains(p: number): boolean;
+    abstract interiorContains(p: number): boolean;
+    toString(): string;
+    /**
+     * Return true if two intervals contains the same set of points.
+     */
+    equals(that: Interval): boolean;
+}
+
+declare class S1Interval extends Interval {
+    constructor(lo: number, hi: number, checked?: boolean);
+    /**
+     * An interval is valid if neither bound exceeds Pi in absolute value, and the
+     * value -Pi appears only in the Empty() and Full() intervals.
+     */
+    isValid(): boolean;
+    /** Return true if the interval contains all points on the unit circle. */
+    isFull(): boolean;
+    /** Return true if the interval is empty, i.e. it contains no points. */
+    isEmpty(): boolean;
+    isInverted(): boolean;
+    /**
+     * Return the midpoint of the interval. For full and empty intervals, the
+     * result is arbitrary.
+     */
+    getCenter(): number;
+    /**
+     * Return the length of the interval. The length of an empty interval is
+     * negative.
+     */
+    getLength(): number;
+    /**
+     * Return the complement of the interior of the interval. An interval and its
+     * complement have the same boundary but do not share any interior values. The
+     * complement operator is not a bijection, since the complement of a singleton
+     * interval (containing a single value) is the same as the complement of an
+     * empty interval.
+     */
+    complement(): S1Interval;
+    /** Return true if the interval (which is closed) contains the point 'p'. */
+    contains(_p: number): boolean;
+    /**
+     * Return true if the interval (which is closed) contains the point 'p'. Skips
+     * the normalization of 'p' from -Pi to Pi.
+     *
+     */
+    fastContains(_p: number): boolean;
+    /** Return true if the interior of the interval contains the point 'p'. */
+    interiorContains(_p: number): boolean;
+    /**
+     * Return true if the interval contains the given interval 'y'. Works for
+     * empty, full, and singleton intervals.
+     */
+    containsI(y: S1Interval): boolean;
+    /**
+     * Returns true if the interior of this interval contains the entire interval
+     * 'y'. Note that x.InteriorContains(x) is true only when x is the empty or
+     * full interval, and x.InteriorContains(S1Interval(p,p)) is equivalent to
+     * x.InteriorContains(p).
+     */
+    interiorContainsI(y: S1Interval): boolean;
+    /**
+     * Return true if the two intervals contain any points in common. Note that
+     * the point +/-Pi has two representations, so the intervals [-Pi,-3] and
+     * [2,Pi] intersect, for example.
+     */
+    intersects(y: S1Interval): boolean;
+    /**
+     * Return true if the interior of this interval contains any point of the
+     * interval 'y' (including its boundary). Works for empty, full, and singleton
+     * intervals.
+     */
+    interiorIntersects(y: S1Interval): boolean;
+    /**
+     * Expand the interval by the minimum amount necessary so that it contains the
+     * given point "p" (an angle in the range [-Pi, Pi]).
+     */
+    addPoint(_p: number): S1Interval;
+    /**
+     * Return an interval that contains all points within a distance "radius" of
+     * a point in this interval. Note that the expansion of an empty interval is
+     * always empty. The radius must be non-negative.
+     */
+    expanded(radius: number): S1Interval;
+    /**
+     * Return the smallest interval that contains this interval and the given
+     * interval "y".
+     */
+    union(y: S1Interval): S1Interval;
+    /**
+     * Return the smallest interval that contains the intersection of this
+     * interval with "y". Note that the region of intersection may consist of two
+     * disjoint intervals.
+     */
+    intersection(y: S1Interval): S1Interval;
+    /**
+     * Return true if the length of the symmetric difference between the two
+     * intervals is at most the given tolerance.
+     */
+    approxEquals(y: S1Interval, maxError?: number): boolean;
+    static empty(): S1Interval;
+    static full(): S1Interval;
+    static fromPoint(_p: number): S1Interval;
+    /**
+     * Convenience method to construct the minimal interval containing the two
+     * given points. This is equivalent to starting with an empty interval and
+     * calling AddPoint() twice, but it is more efficient.
+     */
+    static fromPointPair(_p1: number, _p2: number): S1Interval;
+    /**
+     * Compute the distance from "a" to "b" in the range [0, 2*Pi). This is
+     * equivalent to (drem(b - a - S2.M_PI, 2 * S2.M_PI) + S2.M_PI), except that
+     * it is more numerically stable (it does not lose precision for very small
+     * positive distances).
+     */
+    static positiveDistance(_a: number, _b: number): number;
+}
+
+/**
+ * An R1Interval represents a closed interval on a unit circle (also known as a
+ * 1-dimensional sphere). It is capable of representing the empty interval
+ * (containing no points), the full interval (containing all points), and
+ * zero-length intervals (containing a single point).
+ *
+ *  Points are represented by the angle they make with the positive x-axis in
+ * the range [-Pi, Pi]. An interval is represented by its lower and upper bounds
+ * (both inclusive, since the interval is closed). The lower bound may be
+ * greater than the upper bound, in which case the interval is "inverted" (i.e.
+ * it passes through the point (-1, 0)).
+ *
+ *  Note that the point (-1, 0) has two valid representations, Pi and -Pi. The
+ * normalized representation of this point internally is Pi, so that endpoints
+ * of normal intervals are in the range (-Pi, Pi]. However, we take advantage of
+ * the point -Pi to construct two special intervals: the Full() interval is
+ * [-Pi, Pi], and the Empty() interval is [Pi, -Pi].
+ *
+ */
+declare class R1Interval extends Interval {
+    /** Return true if the interval is empty, i.e. it contains no points. */
+    isEmpty(): boolean;
+    getCenter(): number;
+    getLength(): number;
+    contains(p: number): boolean;
+    /** Return true if the interior of the interval contains the point 'p'. */
+    interiorContains(p: number): boolean;
+    /**
+     * Return true if the interval contains the given interval 'y'. Works for
+     * empty, full, and singleton intervals.
+     */
+    containsI(y: R1Interval): boolean;
+    interiorContainsI(y: R1Interval): boolean;
+    /**
+     * Return true if this interval intersects the given interval, i.e. if they
+     * have any points in common.
+     */
+    intersects(y: R1Interval): boolean;
+    /**
+     * Return true if the interior of this interval intersects any point of the
+     * given interval (including its boundary).
+     */
+    interiorIntersects(y: R1Interval): boolean;
+    /** Expand the interval so that it contains the given point "p". */
+    addPoint(p: number): R1Interval;
+    /**
+     * Return an interval that contains all points with a distance "radius" of a
+     * point in this interval. Note that the expansion of an empty interval is
+     * always empty.
+     */
+    expanded(radius: number): R1Interval;
+    /**
+     * Return the smallest interval that contains this interval and the given
+     * interval "y".
+     */
+    union(y: R1Interval): R1Interval;
+    /**
+     * Return the intersection of this interval with the given interval. Empty
+     * intervals do not need to be special-cased.
+     */
+    intersection(y: R1Interval): R1Interval;
+    /**
+     * Return true if the length of the symmetric difference between the two
+     * intervals is at most the given tolerance.
+     */
+    approxEquals(y: R1Interval, maxError?: number): boolean;
+    static empty(): R1Interval;
+    static fromPoint(p: number): R1Interval;
+    /**
+     * Convenience method to construct the minimal interval containing the two
+     * given points. This is equivalent to starting with an empty interval and
+     * calling AddPoint() twice, but it is more efficient.
+     */
+    static fromPointPair(p1: number, p2: number): R1Interval;
+}
+
+/**
+ * R2Vector represents a vector in the two-dimensional space. It defines the
+ * basic geometrical operations for 2D vectors, e.g. cross product, addition,
+ * norm, comparison etc.
+ *
+ */
+declare class R2Vector {
+    private _x;
+    private _y;
+    constructor(_x: number, _y: number);
+    get x(): number;
+    get y(): number;
+    get(index: number): number;
+    static fromPointFace(p: S2Point, face: number): R2Vector;
+    static add(p1: R2Vector, p2: R2Vector): R2Vector;
+    static mul(p: R2Vector, m: number): R2Vector;
+    norm2(): number;
+    static dotProd(p1: R2Vector, p2: R2Vector): number;
+    dotProd(that: R2Vector): number;
+    crossProd(that: R2Vector): number;
+    lessThan(vb: R2Vector): boolean;
+    static fromSTVector(stVector: R2Vector): R2Vector;
+    static singleStTOUV(s: number): number;
+    static singleUVToST(u: number): number;
+    /**
+     * To be used only if this vector is representing uv.
+     * @param face
+     * @returns {S2Point}
+     */
+    toPoint(face: number): S2Point;
+    toSt(which: number): number;
+    toString(): string;
+}
+
+/**
+ * An S2Point represents a point on the unit sphere as a 3D vector. Usually
+ * points are normalized to be unit length, but some methods do not require
+ * this.
+ *
+ */
+declare class S2Point {
+    /** Origin of the coordinate system, [0,0,0]. */
+    static ORIGIN: S2Point;
+    /** Direction of the x-axis. */
+    static X_POS: S2Point;
+    /** Opposite direction of the x-axis. */
+    static X_NEG: S2Point;
+    /** Direction of the y-axis. */
+    static Y_POS: S2Point;
+    /** Opposite direction of the y-axis. */
+    static Y_NEG: S2Point;
+    /** Direction of the z-axis. */
+    static Z_POS: S2Point;
+    /** Opposite direction of the z-axis. */
+    static Z_NEG: S2Point;
+    x: number;
+    y: number;
+    z: number;
+    constructor(x: number, y: number, z: number);
+    static minus(p1: S2Point, p2: S2Point): S2Point;
+    static neg(p: S2Point): S2Point;
+    norm2(): number;
+    norm(): number;
+    static crossProd(p1: S2Point, p2: S2Point): S2Point;
+    static add(p1: S2Point, p2: S2Point): S2Point;
+    static sub(p1: S2Point, p2: S2Point): S2Point;
+    dotProd(that: S2Point): number;
+    static mul(p: any, m: number): S2Point;
+    static div(p: S2Point, m: number): S2Point;
+    /**
+     * Returns the distance in 3D coordinates from this to that.
+     *
+     * <p>Equivalent to {@code a.sub(b).norm()}, but significantly faster.
+     *
+     * <p>If ordering points by angle, this is faster than {@link #norm}, and much faster than {@link
+    * #angle}, but consider using {@link S1ChordAngle}.
+    */
+    getDistance(that: S2Point): number;
+    /**
+     * Returns the square of the distance in 3D coordinates from this to that.
+     *
+     * <p>Equivalent to {@code getDistance(that)<sup>2</sup>}, but significantly faster.
+     *
+     * <p>If ordering points by angle, this is much faster than {@link #angle}, but consider using
+     * {@link S1ChordAngle}.
+     */
+    getDistance2(that: S2Point): number;
+    /** return a vector orthogonal to this one */
+    ortho(): S2Point;
+    /** Return the index of the largest component fabs */
+    largestAbsComponent(): number;
+    static largestAbsComponent(x: number, y: number, z: number): number;
+    get(axis: number): number;
+    static fabs(p: S2Point): S2Point;
+    /** Returns a copy of 'p' rescaled to be unit-length. */
+    static normalize(p: S2Point): S2Point;
+    axis(axis: number): number;
+    /** Return the angle between two vectors in radians */
+    angle(va: any): number;
+    /**
+     * Compare two vectors, return true if all their components are within a
+     * difference of margin.
+     */
+    aequal(that: S2Point, margin: number): boolean;
+    equals(that: S2Point): boolean;
+    lessThan(vb: S2Point): boolean;
+    compareTo(other: S2Point): number;
+    toFace(): number;
+    toR2Vector(face?: number): R2Vector;
+    toString(): string;
+}
+
+declare class S1Angle {
+    static INFINITY: S1Angle;
+    static ZERO: S1Angle;
+    radians: number;
+    constructor(radians: number);
+    degrees(): number;
+    /**
+     * Return the angle between two points, which is also equal to the distance
+     * between these points on the unit sphere. The points do not need to be
+     * normalized.
+     */
+    static fromPoints(x: S2Point, y: S2Point): S1Angle;
+    lessThan(that: S1Angle): boolean;
+    greaterThan(that: S1Angle): boolean;
+    lessOrEquals(that: S1Angle): boolean;
+    greaterOrEquals(that: S1Angle): boolean;
+    static max(left: S1Angle, right: S1Angle): S1Angle;
+    static min(left: S1Angle, right: S1Angle): S1Angle;
+    static radians(radians: number): S1Angle;
+    static degrees(degrees: number): S1Angle;
+    /**
+   * Retuns an {@link S1Angle} whose angle is <code>(this + a)</code>.
+   */
+    add(a: S1Angle): S1Angle;
+    /**
+     * Retuns an {@link S1Angle} whose angle is <code>(this - a)</code>.
+     */
+    sub(a: S1Angle): S1Angle;
+    /**
+     * Retuns an {@link S1Angle} whose angle is <code>(this * m)</code>.
+     */
+    mul(m: number): S1Angle;
+    /**
+     * Retuns an {@link S1Angle} whose angle is <code>(this / d)</code>.
+     */
+    div(d: number): S1Angle;
+    /**
+     * Returns the trigonometric cosine of the angle.
+     */
+    cos(): number;
+    /**
+     * Returns the trigonometric sine of the angle.
+     */
+    sin(): number;
+    /**
+     * Returns the trigonometric tangent of the angle.
+     */
+    tan(): number;
+    /** Returns the distance along the surface of a sphere of the given radius. */
+    distance(radius: number): number;
+    /**
+     * Writes the angle in degrees with a "d" suffix, e.g. "17.3745d". By default
+     * 6 digits are printed; this can be changed using setprecision(). Up to 17
+     * digits are required to distinguish one angle from another.
+     */
+    toString(): string;
+    compareTo(that: S1Angle): number;
+    equals(that: S1Angle): boolean;
+}
+
+/**
+ * This class represents a point on the unit sphere as a pair of
+ * latitude-longitude coordinates. Like the rest of the "geometry" package, the
+ * intent is to represent spherical geometry as a mathematical abstraction, so
+ * functions that are specifically related to the Earth's geometry (e.g.
+ * easting/northing conversions) should be put elsewhere.
+ *
+ */
+declare class S2LatLng {
+    /**
+     * Approximate "effective" radius of the Earth in meters.
+     */
+    static EARTH_RADIUS_METERS: number;
+    /** The center point the lat/lng coordinate system. */
+    static CENTER: S2LatLng;
+    latRadians: number;
+    lngRadians: number;
+    constructor(latRadians: number, lngRadians: number);
+    get latDegrees(): number;
+    get lngDegrees(): number;
+    /** Convert an S2LatLng to the equivalent unit-length vector (S2Point). */
+    toPoint(): S2Point;
+    /**
+     * Returns a new S2LatLng based on this instance for which {@link #isValid()}
+     * will be {@code true}.
+     * <ul>
+     * <li>Latitude is clipped to the range {@code [-90, 90]}
+     * <li>Longitude is normalized to be in the range {@code [-180, 180]}
+     * </ul>
+     * <p>If the current point is valid then the returned point will have the same
+     * coordinates.
+     */
+    normalized(): S2LatLng;
+    static fromDegrees(latDegrees: number, lngDegrees: number): S2LatLng;
+    static fromRadians(latRadians: number, lngRadians: number): S2LatLng;
+    static fromPoint(p: S2Point): S2LatLng;
+    /** Returns the latitude of this point as a new S1Angle. */
+    lat(): S1Angle;
+    /** Returns the longitude of this point as a new S1Angle. */
+    lng(): S1Angle;
+    /**
+     * Return true if the latitude is between -90 and 90 degrees inclusive and the
+     * longitude is between -180 and 180 degrees inclusive.
+     */
+    isValid(): boolean;
+    /**
+     * Scales this point by the given scaling factor.
+     * Note that there is no guarantee that the new point will be <em>valid</em>.
+     */
+    mul(m: number): S2LatLng;
+    static latitude(p: S2Point): S1Angle;
+    static longitude(p: S2Point): S1Angle;
+    equals(other: S2LatLng): boolean;
+    pointAtDistance(distanceInKM: number, bearingRadians: number): S2LatLng;
+    /**
+     * Generates n LatLngs given a distance in km and the number of points wanted.
+     * Generated points will be returned in a Clockwise order starting from North.
+     * @param _distanceInKm
+     * @param nPoints
+     * @returns {S2LatLng[]}
+     */
+    pointsAtDistance(_distanceInKm: number, nPoints?: number): S2LatLng[];
+    getEarthDistance(other: S2LatLng): number;
+    getDistance(other: S2LatLng): S1Angle;
+    toString(): string;
+    toStringDegrees(): string;
+    toGEOJSON(): {
+        type: string;
+        geometry: {
+            type: string;
+            coordinates: number[];
+        };
+        properties: {};
+    };
+}
+
+declare class MutableInteger {
+    val: number;
+    constructor(val: number);
+}
+
+/**
+ * An S2CellId is a 64-bit unsigned integer that uniquely identifies a cell in
+ * the S2 cell decomposition. It has the following format:
+ *
+ * <pre>
+ * id = [face][face_pos]
+ * </pre>
+ *
+ * face: a 3-bit number (range 0..5) encoding the cube face.
+ *
+ * face_pos: a 61-bit number encoding the position of the center of this cell
+ * along the Hilbert curve over this face (see the Wiki pages for details).
+ *
+ * Sequentially increasing cell ids follow a continuous space-filling curve over
+ * the entire sphere. They have the following properties:
+ *  - The id of a cell at level k consists of a 3-bit face number followed by k
+ * bit pairs that recursively select one of the four children of each cell. The
+ * next bit is always 1, and all other bits are 0. Therefore, the level of a
+ * cell is determined by the position of its lowest-numbered bit that is turned
+ * on (for a cell at level k, this position is 2 * (MAX_LEVEL - k).)
+ *  - The id of a parent cell is at the midpoint of the range of ids spanned by
+ * its children (or by its descendants at any level).
+ *
+ * Leaf cells are often used to represent points on the unit sphere, and this
+ * class provides methods for converting directly between these two
+ * representations. For cells that represent 2D regions rather than discrete
+ * point, it is better to use the S2Cell class.
+ *
+ * v4 CHANGE: S2CellId.id is now a native bigint (unsigned uint64).
+ * The constructor accepts bigint, string (signed or unsigned decimal), or number.
+ */
+declare class S2CellId {
+    static FACE_BITS: number;
+    static NUM_FACES: number;
+    static MAX_LEVEL: number;
+    static POS_BITS: number;
+    static MAX_SIZE: number;
+    /** Maximum unsigned 64-bit value (sentinel). */
+    static MAX_UNSIGNED: bigint;
+    static LOOKUP_BITS: number;
+    private static SWAP_MASK;
+    private static INVERT_MASK;
+    private static I_SHIFT;
+    private static J_SHIFT;
+    private static J_MASK;
+    private static SI_SHIFT;
+    private static ORIENTATION_MASK;
+    private static TI_MASK;
+    /** LOOKUP_POS[10-bit key] = 10-bit value (stored as bigint) */
+    static LOOKUP_POS: bigint[];
+    /** LOOKUP_IJ[10-bit key] = 10-bit value */
+    static LOOKUP_IJ: number[];
+    /**
+     * This is the offset required to wrap around from the beginning of the
+     * Hilbert curve to the end or vice versa; see next_wrap() and prev_wrap().
+     */
+    private static WRAP_OFFSET;
+    /**
+     * The 64-bit unsigned cell ID.
+     * v4: changed from Long to bigint. Always in [0, 2^64-1].
+     */
+    id: bigint;
+    /**
+     * Construct an S2CellId from a bigint, decimal string, or number.
+     *
+     * The string may be signed ("-6533045114107854848") or unsigned
+     * ("11913698959601696768"); both are handled via BigInt.asUintN(64, ...).
+     *
+     * Numbers must be finite integers within the safe-integer range
+     * (|n| ≤ Number.MAX_SAFE_INTEGER = 2^53 − 1). Values outside that range
+     * may have silently lost precision in JS before reaching this constructor,
+     * so a RangeError is thrown. Use a bigint literal for large cell IDs
+     * (e.g. `-9182983676231680000n`).
+     *
+     * @throws {TypeError}  if `id` is a non-integer or non-finite number.
+     * @throws {RangeError} if `id` exceeds safe-integer precision (> 2^53 − 1).
+     */
+    constructor(id: bigint | string | number);
+    /**
+     * Construct an S2CellId from a **signed**-decimal string produced by Java's
+     * Long.toString() or the v3 Long-based API. Equivalent to `new S2CellId(s)`
+     * but makes the intent explicit.
+     *
+     * @example
+     * S2CellId.fromSignedDecimalString('-6533045114107854848')
+     */
+    static fromSignedDecimalString(s: string): S2CellId;
+    /**
+     * Return this cell id as a signed-decimal string, matching the output of
+     * Java's Long.toString() and the v3 Long-based API.
+     *
+     * @example
+     * cellId.toSignedDecimalString() // '-6533045114107854848'
+     */
+    toSignedDecimalString(): string;
+    /**
+     * Return this cell id as an unsigned-decimal string (same as `this.id.toString()`).
+     *
+     * @example
+     * cellId.toUnsignedDecimalString() // '11913698959601696768'
+     */
+    toUnsignedDecimalString(): string;
+    /** Which cube face this cell belongs to, in the range 0..5. */
+    get face(): number;
+    /** Return the lowest-numbered bit that is on for this cell. */
+    lowestOnBit(): bigint;
+    static lowestOnBit(id: bigint): bigint;
+    /** Return an invalid cell id (id == 0). */
+    static none(): S2CellId;
+    /**
+     * Returns an invalid cell id guaranteed to be larger than any valid cell id.
+     * Useful for creating indexes.
+     */
+    static sentinel(): S2CellId;
+    private getBits1;
+    /** Return the lowest-numbered bit that is on for cells at the given level. */
+    static lowestOnBitForLevel(level: number): bigint;
+    /**
+     * @deprecated use `toIJOrientation` instead
+     */
+    toFaceIJOrientation(pi: MutableInteger, pj: MutableInteger, orientation: MutableInteger): number;
+    /**
+     * Return a packed bigint encoding (i << I_SHIFT | j << J_SHIFT | orientation).
+     * Use getI(), getJ(), getOrientation() to unpack.
+     */
+    toIJOrientation(): bigint;
+    getI(): number;
+    static getI(ijo: bigint): number;
+    getJ(): number;
+    static getJ(ijo: bigint): number;
+    static getOrientation(ijo: bigint): number;
+    /** Return true if this is a leaf cell (level() == MAX_LEVEL). */
+    isLeaf(): boolean;
+    /**
+     * Return the cell at the given level (which must be ≤ the current level).
+     */
+    parentL(level: number): S2CellId;
+    parent(): S2CellId;
+    /**
+     * Return a cell given its face (range 0..5), 61-bit Hilbert curve position
+     * within that face, and level (range 0..MAX_LEVEL).
+     *
+     * v4: `pos` is now `bigint` (was `Long`).
+     */
+    static fromFacePosLevel(face: number, pos: bigint, level: number): S2CellId;
+    static fromFace(face: number): S2CellId;
+    static fromPoint(p: S2Point): S2CellId;
+    getCenterUV(): R2Vector;
+    toPoint(): S2Point;
+    /**
+     * Returns packed (si << 32 | ti) as a bigint.
+     * v4: return type changed from Long to bigint.
+     */
+    getCenterSiTi(): bigint;
+    static getSi(center: bigint): number;
+    static getTi(center: bigint): number;
+    toPointRaw(): S2Point;
+    toLatLng(): S2LatLng;
+    /** Return true if id() represents a valid cell. */
+    isValid(): boolean;
+    /**
+     * The position of the cell center along the Hilbert curve over this face,
+     * in the range 0..(2**kPosBits-1).
+     *
+     * v4: return type changed from Long to bigint.
+     */
+    pos(): bigint;
+    /** Return the subdivision level of the cell (range 0..MAX_LEVEL). */
+    level(): number;
+    getSizeIJ(): number;
+    static getSizeIJ(level: number): number;
+    getSizeST(): number;
+    static getSizeST(level: number): number;
+    isFace(): boolean;
+    childPosition(level: number): number;
+    rangeMin(): S2CellId;
+    rangeMax(): S2CellId;
+    contains(other: S2CellId): boolean;
+    intersects(other: S2CellId): boolean;
+    childBegin(): S2CellId;
+    childBeginL(level: number): S2CellId;
+    childEnd(): S2CellId;
+    childEndL(level: number): S2CellId;
+    private static childBeginAsBigInt;
+    private static childBeginAsBigIntL;
+    private static childEndAsBigInt;
+    private static childEndAsBigIntL;
+    private static fromFaceAsBigInt;
+    /** Return the next cell at the same level along the Hilbert curve. */
+    next(): S2CellId;
+    /** Return the previous cell at the same level along the Hilbert curve. */
+    prev(): S2CellId;
+    nextWrap(): S2CellId;
+    prevWrap(): S2CellId;
+    static begin(level: number): S2CellId;
+    static end(level: number): S2CellId;
+    /**
+     * Decodes a cell id from a compact hex token string.
+     * The maximum token length is 16 hex characters.
+     */
+    static fromToken(token: string): S2CellId;
+    /**
+     * Encodes the cell id to a compact hex token string.
+     * Cells at lower levels are encoded into fewer characters.
+     */
+    toToken(): string;
+    getEdgeNeighbors(): S2CellId[];
+    getVertexNeighbors(level: number): S2CellId[];
+    getAllNeighbors(nbrLevel: number): S2CellId[];
+    static fromFaceIJ(face: number, i: number, j: number): S2CellId;
+    private static getBits;
+    private static stToIJ;
+    private static fromFaceIJWrap;
+    static fromFaceIJSame(face: number, i: number, j: number, sameFace: boolean): S2CellId;
+    /** Returns true if x1 < x2 (unsigned comparison). */
+    static unsignedLongLessThan(x1: bigint, x2: bigint): boolean;
+    /** Returns true if x1 > x2 (unsigned comparison). */
+    static unsignedLongGreaterThan(x1: bigint, x2: bigint): boolean;
+    lessThan(x: S2CellId): boolean;
+    greaterThan(x: S2CellId): boolean;
+    lessOrEquals(x: S2CellId): boolean;
+    greaterOrEquals(x: S2CellId): boolean;
+    toString(): string;
+    compareTo(that: S2CellId): number;
+    equals(that: S2CellId): boolean;
+    /**
+     * Binary search in a sorted S2CellId array.
+     * Returns index if found, or -(insertionPoint+1) if not found.
+     *
+     * v4: `_id` accepts bigint, string, number, or S2CellId (was Long, string, or S2CellId).
+     */
+    static binarySearch(ids: S2CellId[], _id: bigint | string | number | S2CellId, low?: number): number;
+    static indexedBinarySearch(ids: S2CellId[], id: bigint | string | number | S2CellId, low?: number): number;
+}
+
+/**
+ * S1ChordAngle represents the angle subtended by a chord (i.e., the straight 3D Cartesian line
+ * segment connecting two points on the unit sphere). Its representation makes it very efficient for
+ * computing and comparing distances, but unlike S1Angle it is only capable of representing angles
+ * between 0 and Pi radians. Generally, S1ChordAngle should only be used in loops where many angles
+ * need to be calculated and compared. Otherwise it is simpler to use S1Angle.
+ *
+ * <p>S1ChordAngle also loses some accuracy as the angle approaches Pi radians. Specifically, the
+ * representation of (Pi - x) radians can be expected to have an error of about (1e-15 / x), with a
+ * maximum error of about 1e-7.
+ */
+
+declare class S1ChordAngle {
+    /** Max value that can be returned from {@link #getLength2()}. */
+    static MAX_LENGTH2: number;
+    /** The zero chord angle. */
+    static ZERO: S1ChordAngle;
+    /** The chord angle of 90 degrees (a "right angle"). */
+    static RIGHT: S1ChordAngle;
+    /** The chord angle of 180 degrees (a "straight angle"). This is the max finite chord angle. */
+    static STRAIGHT: S1ChordAngle;
+    /**
+     * A chord angle larger than any finite chord angle. The only valid operations on {@code INFINITY}
+     * are comparisons and {@link S1Angle} conversions.
+     */
+    static INFINITY: S1ChordAngle;
+    /**
+     * A chord angle smaller than {@link #ZERO}. The only valid operations on {@code NEGATIVE} are
+     * comparisons and {@link S1Angle} conversions.
+     */
+    static NEGATIVE: S1ChordAngle;
+    private length2;
+    /**
+     * S1ChordAngles are represented by the squared chord length, which can range from 0 to {@code
+     * MAX_LENGTH2}. {@link #INFINITY} uses an infinite squared length.
+     */
+    constructor(length2: number);
+    /**
+     * Constructs the S1ChordAngle corresponding to the distance between the two given points. The
+     * points must be unit length.
+     */
+    static fromS2Point(x: S2Point, y: S2Point): S1ChordAngle;
+    /**
+     * Returns a new chord angle approximated from {@code angle} (see {@link
+     * #getS1AngleConstructorMaxError()} for the max magnitude of the error).
+     *
+     * <p>Angles outside the range [0, Pi] are handled as follows:
+     *
+     * <ul>
+     *   <li>{@link S1Angle#INFINITY} is mapped to {@link #INFINITY}
+     *   <li>negative angles are mapped to {@link #NEGATIVE}
+     *   <li>finite angles larger than Pi are mapped to {@link #STRAIGHT}
+     * </ul>
+     *
+     * <p>Note that this operation is relatively expensive and should be avoided. To use {@link
+     * S1ChordAngle} effectively, you should structure your code so that input arguments are converted
+     * to S1ChordAngles at the beginning of your algorithm, and results are converted back to {@link
+     * S1Angle}s only at the end.
+     */
+    static fromS1Angle(angle: S1Angle): S1ChordAngle;
+    /**
+     * Construct an S1ChordAngle from the squared chord length. Note that the argument is
+     * automatically clamped to a maximum of {@code MAX_LENGTH2} to handle possible roundoff errors.
+     * The argument must be non-negative.
+     */
+    static fromLength2(length2: number): S1ChordAngle;
+    /** Returns whether the chord distance is exactly 0. */
+    isZero(): boolean;
+    /** Returns whether the chord distance is negative. */
+    isNegative(): boolean;
+    /** Returns whether the chord distance is exactly (positive) infinity. */
+    isInfinity(): boolean;
+    /** Returns true if the angle is negative or infinity. */
+    isSpecial(): boolean;
+    /**
+     * Returns true if getLength2() is within the normal range of 0 to 4 (inclusive) or the angle is
+     * special.
+     */
+    isValid(): boolean;
+    /**
+     * Convert the chord angle to an {@link S1Angle}. {@link #INFINITY} is converted to {@link
+     * S1Angle#INFINITY}, and {@link #NEGATIVE} is converted to a negative {@link S1Angle}. This
+     * operation is relatively expensive.
+     */
+    toAngle(): S1Angle;
+    /** The squared length of the chord. (Most clients will not need this.) */
+    getLength2(): number;
+    /**
+     * Returns the smallest representable S1ChordAngle larger than this object. This can be used to
+     * convert a "<" comparison to a "<=" comparison.
+     *
+     * <p>Note the following special cases:
+     *
+     * <ul>
+     *   <li>NEGATIVE.successor() == ZERO
+     *   <li>STRAIGHT.successor() == INFINITY
+     *   <li>INFINITY.Successor() == INFINITY
+     * </ul>
+     */
+    /**
+     * As {@link #successor}, but returns the largest representable S1ChordAngle less than this
+     * object.
+     *
+     * <p>Note the following special cases:
+     *
+     * <ul>
+     *   <li>INFINITY.predecessor() == STRAIGHT
+     *   <li>ZERO.predecessor() == NEGATIVE
+     *   <li>NEGATIVE.predecessor() == NEGATIVE
+     * </ul>
+     */
+    /**
+     * Returns a new S1ChordAngle whose chord distance represents the sum of the angular distances
+     * represented by the 'a' and 'b' chord angles.
+     *
+     * <p>Note that this method is much more efficient than converting the chord angles to S1Angles
+     * and adding those. It requires only one square root plus a few additions and multiplications.
+     */
+    static add(a: S1ChordAngle, b: S1ChordAngle): S1ChordAngle;
+    /**
+     * Subtract one S1ChordAngle from another.
+     *
+     * <p>Note that this method is much more efficient than converting the chord angles to S1Angles
+     * and adding those. It requires only one square root plus a few additions and multiplications.
+     */
+    static sub(a: S1ChordAngle, b: S1ChordAngle): S1ChordAngle;
+    /** Returns the smaller of the given instances. */
+    static min(a: S1ChordAngle, b: S1ChordAngle): S1ChordAngle;
+    /** Returns the larger of the given instances. */
+    static max(a: S1ChordAngle, b: S1ChordAngle): S1ChordAngle;
+    /** Returns the square of Math.sin(toAngle().radians()), but computed more efficiently. */
+    static sin2(a: S1ChordAngle): number;
+    /** Returns Math.sin(toAngle().radians()), but computed more efficiently. */
+    static sin(a: S1ChordAngle): number;
+    /** Returns Math.cos(toAngle().radians()), but computed more efficiently. */
+    static cos(a: S1ChordAngle): number;
+    /** Returns Math.tan(toAngle().radians()), but computed more efficiently. */
+    static tan(a: S1ChordAngle): number;
+    /**
+     * Returns a new S1ChordAngle that has been adjusted by the given error bound (which can be
+     * positive or negative). {@code error} should be the value returned by one of the error bound
+     * methods below. For example:
+     *
+     * <pre>
+     *    {@code S1ChordAngle a = new S1ChordAngle(x, y);}
+     *    {@code S1ChordAngle a1 = a.plusError(a.getS2PointConstructorMaxError());}
+     * </pre>
+     *
+     * <p>If this {@link #isSpecial}, we return {@code this}.
+     */
+    plusError(error: number): S1ChordAngle;
+    /** Returns the error in {@link #fromS1Angle}. */
+    getS1AngleConstructorMaxError(): number;
+    /**
+     * There is a relative error of {@code 2.5 * DBL_EPSILON} when computing the squared distance,
+     * plus a relative error of {@code 2 * DBL_EPSILON} and an absolute error of {@code 16 *
+     * DBL_EPSILON^2} because the lengths of the input points may differ from 1 by up to {@code 2 *
+     * DBL_EPSILON} each. (This is the maximum length error in {@link S2Point#normalize}).
+     */
+    getS2PointConstructorMaxError(): number;
+    /** Returns the string of the closest {@link S1Angle} to this chord distance. */
+    toString(): string;
+    compareTo(that: S1ChordAngle): number;
+    equals(that: S1ChordAngle): boolean;
+}
+
+/**
+ * This class represents a spherical cap, i.e. a portion of a sphere cut off by
+ * a plane. The cap is defined by its axis and height. This representation has
+ * good numerical accuracy for very small caps (unlike the (axis,
+ * min-distance-from-origin) representation), and is also efficient for
+ * containment tests (unlike the (axis, angle) representation).
+ *
+ * Here are some useful relationships between the cap height (h), the cap
+ * opening angle (theta), the maximum chord length from the cap's center (d),
+ * and the radius of cap's base (a). All formulas assume a unit radius.
+ *
+ * h = 1 - cos(theta) = 2 sin^2(theta/2) d^2 = 2 h = a^2 + h^2
+ *
+ */
+declare class S2Cap implements S2Region {
+    /**
+     * Multiply a positive number by this constant to ensure that the result of a
+     * floating point operation is at least as large as the true
+     * infinite-precision result.
+     */
+    private static ROUND_UP;
+    axis: S2Point;
+    radius: S1ChordAngle;
+    /**
+     * Create a cap given its axis and the cap height, i.e. the maximum projected
+     * distance along the cap axis from the cap center. 'axis' should be a
+     * unit-length vector.
+     */
+    constructor(axis: S2Point, radius: S1ChordAngle);
+    static fromAxisChord(center: S2Point, radius: S1ChordAngle): S2Cap;
+    /**
+     * Create a cap given its axis and the cap height, i.e. the maximum projected distance along the
+     * cap axis from the cap center. 'axis' should be a unit-length vector.
+     */
+    static fromAxisHeight(axis: S2Point, height: number): S2Cap;
+    /**
+     * Create a cap given its axis and the cap opening angle, i.e. maximum angle
+     * between the axis and a point on the cap. 'axis' should be a unit-length
+     * vector, and 'angle' should be between 0 and 180 degrees.
+     */
+    static fromAxisAngle(axis: S2Point, angle: S1Angle): S2Cap;
+    /**
+     * Create a cap given its axis and its area in steradians. 'axis' should be a unit-length vector,
+     * and 'area' should be between 0 and 4 * M_PI.
+     */
+    static fromAxisArea(axis: S2Point, area: number): S2Cap;
+    /** Return an empty cap, i.e. a cap that contains no points. */
+    static empty(): S2Cap;
+    /** Return a full cap, i.e. a cap that contains all points. */
+    static full(): S2Cap;
+    getCapBound(): S2Cap;
+    height(): number;
+    area(): number;
+    /**
+     * Returns the cap radius as an S1Angle. Since the cap angle is stored internally as an
+     * S1ChordAngle, this method requires a trigonometric operation and may yield a slightly different
+     * result than the value passed to {@link #fromAxisAngle(S2Point, S1Angle)}.
+     */
+    angle(): S1Angle;
+    /**
+     * Returns true if the axis is {@link S2#isUnitLength unit length}, and the angle is less than Pi.
+     *
+     * <p>Negative angles or heights are valid, and represent empty caps.
+     */
+    isValid(): boolean;
+    /** Return true if the cap is empty, i.e. it contains no points. */
+    isEmpty(): boolean;
+    /** Return true if the cap is full, i.e. it contains all points. */
+    isFull(): boolean;
+    /**
+     * Return the complement of the interior of the cap. A cap and its complement have the same
+     * boundary but do not share any interior points. The complement operator is not a bijection,
+     * since the complement of a singleton cap (containing a single point) is the same as the
+     * complement of an empty cap.
+     */
+    complement(): S2Cap;
+    /**
+     * Return true if and only if this cap contains the given other cap (in a set
+     * containment sense, e.g. every cap contains the empty cap).
+     */
+    containsCap(other: S2Cap): boolean;
+    /**
+     * Return true if and only if the interior of this cap intersects the given other cap. (This
+     * relationship is not symmetric, since only the interior of this cap is used.)
+     */
+    interiorIntersects(other: S2Cap): boolean;
+    /**
+     * Return true if and only if the given point is contained in the interior of the region (i.e. the
+     * region excluding its boundary). 'p' should be a unit-length vector.
+     */
+    interiorContains(p: S2Point): boolean;
+    /**
+     * Increase the cap radius if necessary to include the given point. If the cap is empty the axis
+     * is set to the given point, but otherwise it is left unchanged.
+     *
+     * @param p must be {@link S2#isUnitLength unit length}
+     */
+    addPoint(p: S2Point): S2Cap;
+    addCap(other: S2Cap): S2Cap;
+    getRectBound(): S2LatLngRect;
+    mayIntersectC(cell: S2Cell): boolean;
+    /**
+     * Return true if the cap intersects 'cell', given that the cap vertices have
+     * alrady been checked.
+     */
+    intersects(cell: S2Cell, vertices: S2Point[]): boolean;
+    contains(p: S2Point): boolean;
+    containsC(cell: S2Cell): boolean;
+    /**
+     * Return true if the cap axis and height differ by at most "max_error" from
+     * the given cap "other".
+     */
+    approxEquals(other: S2Cap, maxError?: number): boolean;
+    toString(): string;
+    toGEOJSON(): {
+        type: string;
+        geometry: {
+            type: string;
+            coordinates: number[][][];
+        };
+        properties: {};
+    };
+}
+
+declare class S2Cell {
+    private cellID?;
+    private static MAX_CELL_SIZE;
+    private _face;
+    private _level;
+    private _orientation;
+    private uMin;
+    private uMax;
+    private vMin;
+    private vMax;
+    constructor(cellID?: S2CellId);
+    get id(): S2CellId;
+    static fromFace(face: number): S2Cell;
+    static fromFacePosLevel(face: number, pos: number, level: number): S2Cell;
+    static fromPoint(p: S2Point): S2Cell;
+    static fromLatLng(ll: S2LatLng): S2Cell;
+    isLeaf(): boolean;
+    getVertex(k: number): S2Point;
+    /**
+     * Return the k-th vertex of the cell (k = 0,1,2,3). Vertices are returned in
+     * CCW order. The points returned by GetVertexRaw are not necessarily unit
+     * length.
+     */
+    getVertexRaw(k: number): S2Point;
+    getEdge(k: number): S2Point;
+    getEdgeRaw(k: number): S2Point;
+    /**
+     * Return the inward-facing normal of the great circle passing through the
+     * edge from vertex k to vertex k+1 (mod 4). The normals returned by
+     * GetEdgeRaw are not necessarily unit length.
+     *
+     *  If this is not a leaf cell, set children[0..3] to the four children of
+     * this cell (in traversal order) and return true. Otherwise returns false.
+     * This method is equivalent to the following:
+     *
+     *  for (pos=0, id=child_begin(); id != child_end(); id = id.next(), ++pos)
+     * children[i] = S2Cell(id);
+     *
+     * except that it is more than two times faster.
+     */
+    subdivide(): S2Cell[];
+    /**
+     * Return the direction vector corresponding to the center in (s,t)-space of
+     * the given cell. This is the point at which the cell is divided into four
+     * subcells; it is not necessarily the centroid of the cell in (u,v)-space or
+     * (x,y,z)-space. The point returned by GetCenterRaw is not necessarily unit
+     * length.
+     */
+    getCenter(): S2Point;
+    getCenterRaw(): S2Point;
+    /**
+     * Return the center of the cell in (u,v) coordinates (see {@code
+     * S2Projections}). Note that the center of the cell is defined as the point
+     * at which it is recursively subdivided into four children; in general, it is
+     * not at the midpoint of the (u,v) rectangle covered by the cell
+     */
+    getCenterUV(): R2Vector;
+    /**
+     * Return the average area of cells at this level. This is accurate to within
+     * a factor of 1.7 (for S2_QUADRATIC_PROJECTION) and is extremely cheap to
+     * compute.
+     */
+    static averageArea(level: any): number;
+    /**
+     * Return the average area of cells at this level. This is accurate to within
+     * a factor of 1.7 (for S2_QUADRATIC_PROJECTION) and is extremely cheap to
+     * compute.
+     */
+    averageArea(): number;
+    /**
+     * Return the approximate area of this cell. This method is accurate to within
+     * 3% percent for all cell sizes and accurate to within 0.1% for cells at
+     * level 5 or higher (i.e. 300km square or smaller). It is moderately cheap to
+     * compute.
+     */
+    approxArea(): number;
+    exactArea(): number;
+    getCapBound(): S2Cap;
+    private static MAX_ERROR;
+    private static POLE_MIN_LAT;
+    private getPoint;
+    getRectBound(): S2LatLngRect;
+    mayIntersectC(cell: S2Cell): boolean;
+    contains(p: S2Point): boolean;
+    containsC(cell: S2Cell): boolean;
+    private init;
+    get face(): number;
+    get orientation(): number;
+    get level(): number;
+    toString(): string;
+    toGEOJSON(): {
+        type: string;
+        geometry: {
+            type: string;
+            coordinates: number[][][];
+        };
+        properties: {};
+        title: string;
+    };
+}
+
+declare class S2LatLngRect implements S2Region {
+    lat: R1Interval;
+    lng: S1Interval;
+    constructor(lat: R1Interval, lng: S1Interval);
+    static fromLatLng(lo: S2LatLng, hi: S2LatLng): S2LatLngRect;
+    /** The canonical empty rectangle */
+    static empty(): S2LatLngRect;
+    /** The canonical full rectangle. */
+    static full(): S2LatLngRect;
+    /** The full allowable range of latitudes. */
+    static fullLat(): R1Interval;
+    /**
+     * Construct a rectangle from a center point (in lat-lng space) and size in
+     * each dimension. If size.lng is greater than 360 degrees it is clamped,
+     * and latitudes greater than +/- 90 degrees are also clamped. So for example,
+     * FromCenterSize((80,170),(20,20)) -> (lo=(60,150),hi=(90,-170)).
+     */
+    static fromCenterSize(center: S2LatLng, size: S2LatLng): S2LatLngRect;
+    /** Convenience method to construct a rectangle containing a single point. */
+    static fromPoint(p: S2LatLng): S2LatLngRect;
+    /**
+     * Convenience method to construct the minimal bounding rectangle containing
+     * the two given points. This is equivalent to starting with an empty
+     * rectangle and calling AddPoint() twice. Note that it is different than the
+     * S2LatLngRect(lo, hi) constructor, where the first point is always used as
+     * the lower-left corner of the resulting rectangle.
+     */
+    static fromPointPair(p1: S2LatLng, p2: S2LatLng): S2LatLngRect;
+    /**
+     * Return a latitude-longitude rectangle that contains the edge from "a" to
+     * "b". Both points must be unit-length. Note that the bounding rectangle of
+     * an edge can be larger than the bounding rectangle of its endpoints.
+     */
+    static fromEdge(a: S2Point, b: S2Point): S2LatLngRect;
+    /**
+     * Return true if the rectangle is valid, which essentially just means that
+     * the latitude bounds do not exceed Pi/2 in absolute value and the longitude
+     * bounds do not exceed Pi in absolute value.
+     *
+     */
+    isValid(): boolean;
+    lo(): S2LatLng;
+    hi(): S2LatLng;
+    latLo(): S1Angle;
+    latHi(): S1Angle;
+    lngLo(): S1Angle;
+    lngHi(): S1Angle;
+    /**
+     * Return true if the rectangle is empty, i.e. it contains no points at all.
+     */
+    isEmpty(): boolean;
+    isFull(): boolean;
+    /**
+     * Return true if lng_.lo() > lng_.hi(), i.e. the rectangle crosses the 180
+     * degree latitude line.
+     */
+    isInverted(): boolean;
+    /** Return the k-th vertex of the rectangle (k = 0,1,2,3) in CCW order. */
+    getVertex(k: number): S2LatLng;
+    /**
+     * Return the center of the rectangle in latitude-longitude space (in general
+     * this is not the center of the region on the sphere).
+     */
+    getCenter(): S2LatLng;
+    /**
+     * Return the minimum distance (measured along the surface of the sphere)
+     * from a given point to the rectangle (both its boundary and its interior).
+     * The latLng must be valid.
+     */
+    getDistanceLL(p: S2LatLng): S1Angle;
+    /**
+     * Return the minimum distance (measured along the surface of the sphere) to
+     * the given S2LatLngRect. Both S2LatLngRects must be non-empty.
+     */
+    getDistanceLLR(other: S2LatLngRect): S1Angle;
+    /**
+     * Return the width and height of this rectangle in latitude-longitude space.
+     * Empty rectangles have a negative width and height.
+     */
+    getSize(): S2LatLng;
+    /**
+     * More efficient version of Contains() that accepts a S2LatLng rather than an
+     * S2Point.
+     */
+    containsLL(ll: S2LatLng): boolean;
+    /**
+     * Return true if and only if the given point is contained in the interior of
+     * the region (i.e. the region excluding its boundary). The point 'p' does not
+     * need to be normalized.
+     */
+    interiorContainsP(p: S2Point): boolean;
+    /**
+     * More efficient version of InteriorContains() that accepts a S2LatLng rather
+     * than an S2Point.
+     */
+    interiorContainsLL(ll: S2LatLng): boolean;
+    /**
+     * Return true if and only if the rectangle contains the given other
+     * rectangle.
+     */
+    containsLLR(other: S2LatLngRect): boolean;
+    /**
+     * Return true if and only if the interior of this rectangle contains all
+     * points of the given other rectangle (including its boundary).
+     */
+    interiorContainsLLR(other: S2LatLngRect): boolean;
+    /** Return true if this rectangle and the given other rectangle have any
+     points in common. */
+    intersectsLLR(other: S2LatLngRect): boolean;
+    /**
+     * Returns true if this rectangle intersects the given cell. (This is an exact
+     * test and may be fairly expensive, see also MayIntersect below.)
+     */
+    intersects(cell: S2Cell): boolean;
+    /**
+     * Return true if and only if the interior of this rectangle intersects any
+     * point (including the boundary) of the given other rectangle.
+     */
+    interiorIntersects(other: S2LatLngRect): boolean;
+    addPoint(p: S2Point): S2LatLngRect;
+    addPointLL(ll: S2LatLng): S2LatLngRect;
+    /**
+     * Return a rectangle that contains all points whose latitude distance from
+     * this rectangle is at most margin.lat, and whose longitude distance from
+     * this rectangle is at most margin.lng. In particular, latitudes are
+     * clamped while longitudes are wrapped. Note that any expansion of an empty
+     * interval remains empty, and both components of the given margin must be
+     * non-negative.
+     *
+     * NOTE: If you are trying to grow a rectangle by a certain *distance* on the
+     * sphere (e.g. 5km), use the ConvolveWithCap() method instead.
+     */
+    expanded(margin: S2LatLng): S2LatLngRect;
+    polarClosure(): S2LatLngRect;
+    /**
+     * Return the smallest rectangle containing the union of this rectangle and
+     * the given rectangle.
+     */
+    union(other: S2LatLngRect): S2LatLngRect;
+    /**
+     * Return the smallest rectangle containing the intersection of this rectangle
+     * and the given rectangle. Note that the region of intersection may consist
+     * of two disjoint rectangles, in which case a single rectangle spanning both
+     * of them is returned.
+     */
+    intersection(other: S2LatLngRect): S2LatLngRect;
+    /** Return the surface area of this rectangle on the unit sphere. */
+    area(): number;
+    /** Return true if two rectangles contains the same set of points. */
+    equals(that: S2LatLngRect): boolean;
+    /**
+     * Return true if the latitude and longitude intervals of the two rectangles
+     * are the same up to the given tolerance (see r1interval.h and s1interval.h
+     * for details).
+     */
+    approxEquals(other: S2LatLngRect, maxError?: number): boolean;
+    clone(): S2Region;
+    getCapBound(): S2Cap;
+    getRectBound(): S2LatLngRect;
+    containsC(cell: S2Cell): boolean;
+    /**
+     * This test is cheap but is NOT exact. Use Intersects() if you want a more
+     * accurate and more expensive test. Note that when this method is used by an
+     * S2RegionCoverer, the accuracy isn't all that important since if a cell may
+     * intersect the region then it is subdivided, and the accuracy of this method
+     * goes up as the cells get smaller.
+     */
+    mayIntersectC(cell: S2Cell): boolean;
+    /** The point 'p' does not need to be normalized. */
+    containsP(p: S2Point): boolean;
+    /**
+     * Return true if the edge AB intersects the given edge of constant longitude.
+     */
+    private static intersectsLngEdge;
+    /**
+     * Return true if the edge AB intersects the given edge of constant latitude.
+     */
+    private static intersectsLatEdge;
+    allVertex(): S2LatLng[];
+    toGEOJSON(): {
+        type: string;
+        geometry: {
+            type: string;
+            coordinates: number[][][];
+        };
+        properties: {};
+    };
+    toString(): string;
+}
+
+/**
+ * An S2Region represents a two-dimensional region over the unit sphere. It is
+ * an abstract interface with various concrete subtypes.
+ *
+ *  The main purpose of this interface is to allow complex regions to be
+ * approximated as simpler regions. So rather than having a wide variety of
+ * virtual methods that are implemented by all subtypes, the interface is
+ * restricted to methods that are useful for computing approximations.
+ *
+ *
+ */
+interface S2Region {
+    /** Return a bounding spherical cap. */
+    getCapBound(): S2Cap;
+    /** Return a bounding latitude-longitude rectangle. */
+    getRectBound(): S2LatLngRect;
+    /**
+     * If this method returns true, the region completely contains the given cell.
+     * Otherwise, either the region does not contain the cell or the containment
+     * relationship could not be determined.
+     */
+    containsC(cell: S2Cell): boolean;
+    /**
+     * If this method returns false, the region does not intersect the given cell.
+     * Otherwise, either region intersects the cell, or the intersection
+     * relationship could not be determined.
+     */
+    mayIntersectC(cell: S2Cell): boolean;
+}
+
+/**
+ * Utility helpers for unsigned 64-bit bigint arithmetic.
+ *
+ * All values stored in S2CellId.id are guaranteed to be in [0, 2^64-1].
+ * Use u64() to mask any operation that can produce an out-of-range value
+ * (addition, subtraction, multiplication, shift-left, bitwise-not, negation).
+ */
+/** Mask a bigint value to the unsigned 64-bit range [0, 2^64-1]. */
+declare function u64(n: bigint): bigint;
+/** Extract the lower 32 bits as an unsigned JS number [0, 2^32-1]. */
+declare function low32(n: bigint): number;
+/**
+ * Extract the lower 32 bits as a signed JS number [-2^31, 2^31-1].
+ * Equivalent to Java Long.getLowBits().
+ */
+declare function low32s(n: bigint): number;
+/** Maximum value of a uint64: 2^64 - 1 */
+declare const UINT64_MAX = 18446744073709551615n;
+
+/**
+ * Transitional utilities for consumers migrating from nodes2-ts v3 (Long-based API)
+ * to v4 (bigint-based API).
+ *
+ * These helpers make it easy to work with signed-decimal cell ID strings that
+ * older code or Java S2 libraries produce (e.g. "-6533045114107854848") alongside
+ * the new unsigned bigint representation.
+ */
+/**
+ * Convert a signed-decimal string (as produced by Java's Long.toString()) to an
+ * unsigned 64-bit bigint.
+ *
+ * @example
+ * signedDecimalToUnsigned('-6533045114107854848')
+ * // => 11913698959601696768n
+ */
+declare function signedDecimalToUnsigned(s: string): bigint;
+/**
+ * Convert an unsigned 64-bit bigint back to a signed-decimal string, as Java's
+ * Long.toString() would produce.
+ *
+ * @example
+ * unsignedToSignedDecimal(11913698959601696768n)
+ * // => '-6533045114107854848'
+ */
+declare function unsignedToSignedDecimal(id: bigint): string;
+/**
+ * Convenience: convert a signed-decimal S2 cell ID string (from Java) to its
+ * token representation.
+ *
+ * @example
+ * signedDecimalTokenMap('-6533045114107854848')
+ * // => 'a555f6151'
+ */
+declare function signedDecimalTokenMap(signedId: string): string;
+
+/**
+ * Defines an area or a length cell metric.
+ */
+declare class S2Metric {
+    private _dim;
+    private _deriv;
+    /**
+     * Defines a cell metric of the given dimension (1 == length, 2 == area).
+     */
+    constructor(_dim: number, _deriv: number);
+    deriv(): number;
+    dim(): number;
+    /** Return the value of a metric for cells at the given level. */
+    getValue(level: number): number;
+    /**
+     * Return the level at which the metric has approximately the given value.
+     * For example, S2::kAvgEdge.GetClosestLevel(0.1) returns the level at which
+     * the average cell edge length is approximately 0.1. The return value is
+     * always a valid level.
+     */
+    getClosestLevel(/*double*/ value: number): number;
+    /**
+     * Return the minimum level such that the metric is at most the given value,
+     * or S2CellId::kMaxLevel if there is no such level. For example,
+     * S2::kMaxDiag.GetMinLevel(0.1) returns the minimum level such that all
+     * cell diagonal lengths are 0.1 or smaller. The return value is always a
+     * valid level.
+     */
+    getMinLevel(value: number): number;
+    /**
+     * Return the maximum level such that the metric is at least the given
+     * value, or zero if there is no such level. For example,
+     * S2.kMinWidth.GetMaxLevel(0.1) returns the maximum level such that all
+     * cells have a minimum width of 0.1 or larger. The return value is always a
+     * valid level.
+     */
+    getMaxLevel(value: number): number;
+}
+
+declare class S2 {
+    static M_PI: number;
+    static M_1_PI: number;
+    static M_PI_2: number;
+    static M_PI_4: number;
+    static M_SQRT2: number;
+    static M_E: number;
+    static SWAP_MASK: number;
+    static INVERT_MASK: number;
+    /** Mapping from cell orientation + Hilbert traversal to IJ-index. */
+    static POS_TO_ORIENTATION: number[];
+    static DBL_EPSILON: number;
+    static POS_TO_IJ: number[][];
+    static MAX_LEVEL: number;
+    static IEEEremainder(f1: number, f2: number): number;
+    /**
+     * Return true if the given point is approximately unit length (this is mainly
+     * useful for assertions).
+     */
+    static isUnitLength(p: S2Point): boolean;
+    /**
+     * If v is non-zero, return an integer {@code exp} such that
+     * {@code (0.5 <= |v|*2^(-exp) < 1)}. If v is zero, return 0.
+     *
+     * <p>Note that this arguably a bad definition of exponent because it makes
+     * {@code exp(9) == 4}. In decimal this would be like saying that the
+     * exponent of 1234 is 4, when in scientific 'exponent' notation 1234 is
+     * {@code 1.234 x 10^3}.
+     *
+     * TODO(dbeaumont): Replace this with "DoubleUtils.getExponent(v) - 1" ?
+     */
+    static exp(v: number): number;
+    /**
+     * Return a vector "c" that is orthogonal to the given unit-length vectors "a"
+     * and "b". This function is similar to a.CrossProd(b) except that it does a
+     * better job of ensuring orthogonality when "a" is nearly parallel to "b",
+     * and it returns a non-zero result even when a == b or a == -b.
+     *
+     *  It satisfies the following properties (RCP == RobustCrossProd):
+     *
+     *  (1) RCP(a,b) != 0 for all a, b (2) RCP(b,a) == -RCP(a,b) unless a == b or
+     * a == -b (3) RCP(-a,b) == -RCP(a,b) unless a == b or a == -b (4) RCP(a,-b)
+     * == -RCP(a,b) unless a == b or a == -b
+     */
+    static robustCrossProd(a: S2Point, b: S2Point): S2Point;
+    /**
+     * Return the area of triangle ABC. The method used is about twice as
+     * expensive as Girard's formula, but it is numerically stable for both large
+     * and very small triangles. The points do not need to be normalized. The area
+     * is always positive.
+     *
+     *  The triangle area is undefined if it contains two antipodal points, and
+     * becomes numerically unstable as the length of any edge approaches 180
+     * degrees.
+     */
+    static area(a: S2Point, b: S2Point, c: S2Point): number;
+    /**
+     * Return the area of the triangle computed using Girard's formula. This is
+     * slightly faster than the Area() method above is not accurate for very small
+     * triangles.
+     */
+    static girardArea(a: S2Point, b: S2Point, c: S2Point): number;
+    /**
+     * Return true if the points A, B, C are strictly counterclockwise. Return
+     * false if the points are clockwise or colinear (i.e. if they are all
+     * contained on some great circle).
+     *
+     *  Due to numerical errors, situations may arise that are mathematically
+     * impossible, e.g. ABC may be considered strictly CCW while BCA is not.
+     * However, the implementation guarantees the following:
+     *
+     *  If SimpleCCW(a,b,c), then !SimpleCCW(c,b,a) for all a,b,c.
+     *
+     * In other words, ABC and CBA are guaranteed not to be both CCW
+     */
+    static simpleCCW(a: S2Point, b: S2Point, c: S2Point): boolean;
+    /**
+     *
+     * Return true if edge AB crosses CD at a point that is interior to both
+     * edges. Properties:
+     *
+     *  (1) SimpleCrossing(b,a,c,d) == SimpleCrossing(a,b,c,d) (2)
+     * SimpleCrossing(c,d,a,b) == SimpleCrossing(a,b,c,d)
+     */
+    static simpleCrossing(a: S2Point, b: S2Point, c: S2Point, d: S2Point): boolean;
+    static approxEqualsPointError(a: S2Point, b: S2Point, maxError: number): boolean;
+    static approxEqualsPoint(a: S2Point, b: S2Point): boolean;
+    static approxEqualsNumberError(a: number, b: number, maxError: number): boolean;
+    static approxEqualsNumber(a: number, b: number): boolean;
+    static Metric: typeof S2Metric;
+}
+
+/**
+ * An S2CellUnion is a region consisting of cells of various sizes.
+ */
+declare class S2CellUnion implements S2Region {
+    /** The CellIds that form the Union */
+    private cellIds;
+    /**
+     * Populates a cell union with the given S2CellIds or 64-bit cell ids, and
+     * then calls Normalize().
+     *
+     * v4: `cellIds` accepts `bigint[] | string[] | number[]` (was `Long[] | string[]`).
+     */
+    initFromIds(cellIds: bigint[] | string[] | number[]): void;
+    initFromCellIds(cellIds: S2CellId[]): void;
+    initSwap(cellIds: S2CellId[]): void;
+    initRawCellIds(cellIds: S2CellId[]): void;
+    initRawIds(cellIds: bigint[] | string[] | number[]): void;
+    initRawSwap(cellIds: S2CellId[]): void;
+    size(): number;
+    cellId(i: number): S2CellId;
+    getCellIds(): S2CellId[];
+    denormalize(minLevel: number, levelMod: number): S2CellId[];
+    pack(): void;
+    containsC(cell: S2Cell): boolean;
+    mayIntersectC(cell: S2Cell): boolean;
+    contains(id: S2CellId): boolean;
+    intersects(id: S2CellId): boolean;
+    containsUnion(that: S2CellUnion): boolean;
+    containsCell(cell: S2Cell): boolean;
+    intersectsUnion(that: S2CellUnion): boolean;
+    getUnion(x: S2CellUnion, y: S2CellUnion): void;
+    getIntersection(x: S2CellUnion, id: S2CellId): void;
+    getIntersectionUU(x: S2CellUnion, y: S2CellUnion): void;
+    expand(level: number): void;
+    expandA(minRadius: S1Angle, maxLevelDiff: number): void;
+    getCapBound(): S2Cap;
+    getRectBound(): S2LatLngRect;
+    mayIntersectCell(cell: S2Cell): boolean;
+    containsPoint(p: S2Point): boolean;
+    /**
+     * The number of leaf cells covered by the union.
+     *
+     * v4: return type changed from Long to bigint.
+     */
+    leafCellsCovered(): bigint;
+    /**
+     * Approximate area by summing the average area of each contained cell.
+     *
+     * v4: uses Number(bigint) instead of Long.toNumber().
+     */
+    averageBasedArea(): number;
+    approxArea(): number;
+    exactArea(): number;
+    normalize(): boolean;
+}
+
+/**
+ * This class specifies the details of how the cube faces are projected onto the
+ * unit sphere. This includes getting the face ordering and orientation correct
+ * so that sequentially increasing cell ids follow a continuous space-filling
+ * curve over the entire sphere, and defining the transformation from cell-space
+ * to cube-space (see s2.h) in order to make the cells more uniform in size.
+ *
+ *
+ *  We have implemented three different projections from cell-space (s,t) to
+ * cube-space (u,v): linear, quadratic, and tangent. They have the following
+ * tradeoffs:
+ *
+ *  Linear - This is the fastest transformation, but also produces the least
+ * uniform cell sizes. Cell areas vary by a factor of about 5.2, with the
+ * largest cells at the center of each face and the smallest cells in the
+ * corners.
+ *
+ *  Tangent - Transforming the coordinates via atan() makes the cell sizes more
+ * uniform. The areas vary by a maximum ratio of 1.4 as opposed to a maximum
+ * ratio of 5.2. However, each call to atan() is about as expensive as all of
+ * the other calculations combined when converting from points to cell ids, i.e.
+ * it reduces performance by a factor of 3.
+ *
+ *  Quadratic - This is an approximation of the tangent projection that is much
+ * faster and produces cells that are almost as uniform in size. It is about 3
+ * times faster than the tangent projection for converting cell ids to points,
+ * and 2 times faster for converting points to cell ids. Cell areas vary by a
+ * maximum ratio of about 2.1.
+ *
+ *  Here is a table comparing the cell uniformity using each projection. "Area
+ * ratio" is the maximum ratio over all subdivision levels of the largest cell
+ * area to the smallest cell area at that level, "edge ratio" is the maximum
+ * ratio of the longest edge of any cell to the shortest edge of any cell at the
+ * same level, and "diag ratio" is the ratio of the longest diagonal of any cell
+ * to the shortest diagonal of any cell at the same level. "ToPoint" and
+ * "FromPoint" are the times in microseconds required to convert cell ids to and
+ * from points (unit vectors) respectively.
+ *
+ *  Area Edge Diag ToPoint FromPoint Ratio Ratio Ratio (microseconds)
+ * ------------------------------------------------------- Linear: 5.200 2.117
+ * 2.959 0.103 0.123 Tangent: 1.414 1.414 1.704 0.290 0.306 Quadratic: 2.082
+ * 1.802 1.932 0.116 0.161
+ *
+ *  The worst-case cell aspect ratios are about the same with all three
+ * projections. The maximum ratio of the longest edge to the shortest edge
+ * within the same cell is about 1.4 and the maximum ratio of the diagonals
+ * within the same cell is about 1.7.
+ *
+ * This data was produced using s2cell_unittest and s2cellid_unittest.
+ *
+ */
+
+type UvTransformFunction = (x: number, y: number, z: number) => number;
+type XyzTransformFunction = (u: number, v: number) => number;
+type UvTransform = {
+    xyzToU: UvTransformFunction;
+    xyzToV: UvTransformFunction;
+};
+type XyzTransform = {
+    uvToX: XyzTransformFunction;
+    uvToY: XyzTransformFunction;
+    uvToZ: XyzTransformFunction;
+};
+declare class S2Projections {
+    static MIN_WIDTH: S2Metric;
+    static AVG_AREA: S2Metric;
+    static MAX_LEVEL: number;
+    private static FACE_UVW_AXES;
+    private static UV_TRANSFORMS;
+    private static XYZ_TRANSFORMS;
+    /**
+     * The maximum value of an si- or ti-coordinate. The range of valid (si,ti) values is
+     * [0..MAX_SiTi].
+     */
+    static MAX_SITI: bigint;
+    static getUNorm(face: number, u: number): S2Point;
+    static getVNorm(face: number, v: number): S2Point;
+    static getUAxis(face: number): S2Point;
+    static getVAxis(face: number): S2Point;
+    static getNorm(face: number): S2Point;
+    /** Returns the given axis of the given face (u=0, v=1, w=2). */
+    static getUVWAxis(face: number, axis: number): S2Point;
+    /**
+     * Convert (face, si, ti) coordinates (see s2.h) to a direction vector (not
+     * necessarily unit length).
+     */
+    static faceSiTiToXYZ(face: number, si: number, ti: number): S2Point;
+    static faceUvToXyz(face: number, u: number, v: number): S2Point;
+    static faceXyzToUv(face: number, p: S2Point): R2Vector;
+    static validFaceXyzToUv(face: number, p: S2Point): R2Vector;
+    static ijToStMin(i: number): number;
+    static stToIj(s: number): number;
+    static siTiToSt(si: number): number;
+    static ijToUV(ij: number, cellSize: number): number;
+    static xyzToFaceP(p: S2Point): number;
+    static xyzToFace(x: number, y: number, z: number): number;
+    static faceToUvTransform(face: number): UvTransform;
+    static faceToXyzTransform(face: number): XyzTransform;
+}
+
+/**
+ * An S2RegionCoverer is a class that allows arbitrary regions to be
+ * approximated as unions of cells (S2CellUnion). This is useful for
+ * implementing various sorts of search and precomputation operations.
+ *
+ * Typical usage: {@code S2RegionCoverer coverer; coverer.setMaxCells(5); S2Cap
+ * cap = S2Cap.fromAxisAngle(...); S2CellUnion covering;
+ * coverer.getCovering(cap, covering); * }
+ *
+ * This yields a cell union of at most 5 cells that is guaranteed to cover the
+ * given cap (a disc-shaped region on the sphere).
+ *
+ *  The approximation algorithm is not optimal but does a pretty good job in
+ * practice. The output does not always use the maximum number of cells allowed,
+ * both because this would not always yield a better approximation, and because
+ * max_cells() is a limit on how much work is done exploring the possible
+ * covering as well as a limit on the final output size.
+ *
+ *  One can also generate interior coverings, which are sets of cells which are
+ * entirely contained within a region. Interior coverings can be empty, even for
+ * non-empty regions, if there are no cells that satisfy the provided
+ * constraints and are contained by the region. Note that for performance
+ * reasons, it is wise to specify a max_level when computing interior coverings
+ * - otherwise for regions with small or zero area, the algorithm may spend a
+ * lot of time subdividing cells all the way to leaf level to try to find
+ * contained cells.
+ *
+ *  This class is thread-unsafe. Simultaneous calls to any of the getCovering
+ * methods will conflict and produce unpredictable results.
+ *
+ */
+declare class S2RegionCoverer {
+    /**
+     * By default, the covering uses at most 8 cells at any level. This gives a
+     * reasonable tradeoff between the number of cells used and the accuracy of
+     * the approximation (see table below).
+     */
+    static DEFAULT_MAX_CELLS: number;
+    private static FACE_CELLS;
+    private minLevel;
+    private maxLevel;
+    private levelMod;
+    private maxCells;
+    private interiorCovering;
+    private candidatesCreatedCounter;
+    /**
+     * We save a temporary copy of the pointer passed to GetCovering() in order to
+     * avoid passing this parameter around internally. It is only used (and only
+     * valid) for the duration of a single GetCovering() call.
+     */
+    protected region: S2Region;
+    /**
+     * A temporary variable used by GetCovering() that holds the cell ids that
+     * have been added to the covering so far.
+     */
+    protected result: S2CellId[];
+    /**
+     * We keep the candidates in a priority queue. We specify a vector to hold the
+     * queue entries since for some reason priority_queue<> uses a deque by
+     * default.
+     */
+    private candidateQueue;
+    /**
+     * Default constructor, sets all fields to default values.
+     */
+    constructor();
+    /**
+     * Sets the minimum level to be used.
+     */
+    setMinLevel(minLevel: number): S2RegionCoverer;
+    /**
+     * Sets the maximum level to be used.
+     */
+    setMaxLevel(maxLevel: number): S2RegionCoverer;
+    /**
+     * If specified, then only cells where (level - min_level) is a multiple of
+     * "level_mod" will be used (default 1). This effectively allows the branching
+     * factor of the S2CellId hierarchy to be increased. Currently the only
+     * parameter values allowed are 1, 2, or 3, corresponding to branching factors
+     * of 4, 16, and 64 respectively.
+     */
+    setLevelMod(levelMod: number): S2RegionCoverer;
+    /**
+     * Sets the maximum desired number of cells in the approximation (defaults to
+     * kDefaultMaxCells). Note the following:
+     *
+     * <ul>
+     * <li>For any setting of max_cells(), up to 6 cells may be returned if that
+     * is the minimum number of cells required (e.g. if the region intersects all
+     * six face cells). Up to 3 cells may be returned even for very tiny convex
+     * regions if they happen to be located at the intersection of three cube
+     * faces.
+     *
+     * <li>For any setting of max_cells(), an arbitrary number of cells may be
+     * returned if min_level() is too high for the region being approximated.
+     *
+     * <li>If max_cells() is less than 4, the area of the covering may be
+     * arbitrarily large compared to the area of the original region even if the
+     * region is convex (e.g. an S2Cap or S2LatLngRect).
+     * </ul>
+     *
+     * Accuracy is measured by dividing the area of the covering by the area of
+     * the original region. The following table shows the median and worst case
+     * values for this area ratio on a test case consisting of 100,000 spherical
+     * caps of random size (generated using s2regioncoverer_unittest):
+     *
+     * <pre>
+     * max_cells: 3 4 5 6 8 12 20 100 1000
+     * median ratio: 5.33 3.32 2.73 2.34 1.98 1.66 1.42 1.11 1.01
+     * worst case: 215518 14.41 9.72 5.26 3.91 2.75 1.92 1.20 1.02
+     * </pre>
+     */
+    setMaxCells(maxCells: number): S2RegionCoverer;
+    getMinLevel(): number;
+    getMaxLevel(): number;
+    getMaxCells(): number;
+    getLevelMod(): number;
+    /**
+     * Computes a list of cell ids that covers the given region and satisfies the
+     * various restrictions specified above.
+     *
+     * @param region The region to cover
+     * @param covering The list filled in by this method
+     */
+    getCoveringCells(region: S2Region): S2CellId[];
+    /**
+     * Computes a list of cell ids that is contained within the given region and
+     * satisfies the various restrictions specified above.
+     *
+     * @param region The region to fill
+     * @param interior The list filled in by this method
+     */
+    getInteriorCoveringCells(region: S2Region): S2CellId[];
+    /**
+     * Return a normalized cell union that covers the given region and satisfies
+     * the restrictions *EXCEPT* for min_level() and level_mod(). These criteria
+     * cannot be satisfied using a cell union because cell unions are
+     * automatically normalized by replacing four child cells with their parent
+     * whenever possible. (Note that the list of cell ids passed to the cell union
+     * constructor does in fact satisfy all the given restrictions.)
+     */
+    getCoveringUnion(region: S2Region, covering?: S2CellUnion): S2CellUnion;
+    /**
+     * Return a normalized cell union that is contained within the given region
+     * and satisfies the restrictions *EXCEPT* for min_level() and level_mod().
+     */
+    getInteriorCoveringUnion(region: S2Region, covering?: S2CellUnion): S2CellUnion;
+    /**
+     * Given a connected region and a starting point, return a set of cells at the given level that
+     * cover the region.
+     */
+    static getSimpleCovering(region: S2Region, start: S2Point, level: number): S2CellId[];
+    /**
+     * If the cell intersects the given region, return a new candidate with no
+     * children, otherwise return null. Also marks the candidate as "terminal" if
+     * it should not be expanded further.
+     */
+    private newCandidate;
+    /** Return the log base 2 of the maximum number of children of a candidate. */
+    private maxChildrenShift;
+    /**
+     * Process a candidate by either adding it to the result list or expanding its
+     * children and inserting it into the priority queue. Passing an argument of
+     * NULL does nothing.
+     */
+    private addCandidate;
+    /**
+     * Populate the children of "candidate" by expanding the given number of
+     * levels from the given cell. Returns the number of children that were marked
+     * "terminal".
+     */
+    private expandChildren;
+    /** Computes a set of initial candidates that cover the given region. */
+    private getInitialCandidates;
+    /** Generates a covering and stores it in result. */
+    private getCoveringInternal;
+    /**
+     * Given a region and a starting cell, return the set of all the edge-connected cells at the same
+     * level that intersect "region". The output cells are returned in arbitrary order.
+     */
+    private static floodFill;
+}
+
+declare class Utils {
     /**
      * Calculates a region covering a circle
      * NOTE: The current implementation uses S2Cap while S2Loop would be better (S2Loop is not implemented yet)
@@ -28,3 +1843,5 @@ export declare class Utils {
      */
     static calcRegionFromCenterRadius(center: S2LatLng, radiusInKM: number, points?: number): S2Region;
 }
+
+export { Interval, MutableInteger, R1Interval, R2Vector, S1Angle, S1Interval, S2, S2Cap, S2Cell, S2CellId, S2CellUnion, S2LatLng, S2LatLngRect, S2Metric, S2Point, S2Projections, type S2Region, S2RegionCoverer, UINT64_MAX, Utils, type UvTransform, type UvTransformFunction, type XyzTransform, type XyzTransformFunction, low32, low32s, signedDecimalToUnsigned, signedDecimalTokenMap, u64, unsignedToSignedDecimal };