@neilberkman/sidereon 0.8.0

package/pkg-node/sidereon.d.ts

@@ -0,0 +1,3938 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Acquisition search-grid metadata.
+ */
+export class AcquisitionGrid {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of code-phase bins searched.
+     */
+    readonly codePhaseBins: number;
+    /**
+     * Doppler bins searched, hertz, as a `Float64Array`.
+     */
+    readonly dopplerHz: Float64Array;
+    /**
+     * Doppler step, hertz.
+     */
+    readonly dopplerStepHz: number;
+    /**
+     * Samples per C/A chip.
+     */
+    readonly samplesPerChip: number;
+}
+
+/**
+ * Result of a 2D C/A code-phase and Doppler acquisition search.
+ */
+export class AcquisitionResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Recovered C/A code phase, chips.
+     */
+    readonly codePhaseChips: number;
+    /**
+     * Recovered Doppler bin, hertz.
+     */
+    readonly dopplerHz: number;
+    /**
+     * Search-grid metadata.
+     */
+    readonly grid: AcquisitionGrid;
+    /**
+     * Alias of `peakMetric`.
+     */
+    readonly metric: number;
+    /**
+     * Peak-to-mean-off-peak acquisition metric.
+     */
+    readonly peakMetric: number;
+    /**
+     * Peak correlator power.
+     */
+    readonly peakPower: number;
+}
+
+/**
+ * A receiver or satellite ANTEX antenna calibration block.
+ */
+export class Antenna {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Frequency-dependent phase-center offset, north/east/up metres, as a
+     * length-3 `Float64Array`.
+     */
+    pco(frequency: string): Float64Array;
+    /**
+     * Frequency-dependent phase-center variation, metres. `azimuthDeg` is
+     * optional; without it the no-azimuth interpolation is used.
+     */
+    pcv(frequency: string, zenith_deg: number, azimuth_deg?: number | null): number;
+    /**
+     * Whether this antenna block is valid at `epoch`.
+     */
+    validAt(epoch: AntexDateTime): boolean;
+    /**
+     * ANTEX antenna type field.
+     */
+    readonly antennaType: string;
+    /**
+     * Azimuth grid spacing, degrees.
+     */
+    readonly daziDeg: number;
+    /**
+     * Available frequency codes, e.g. `"G01"`.
+     */
+    readonly frequencies: string[];
+    /**
+     * ANTEX `TYPE / SERIAL` id.
+     */
+    readonly id: string;
+    /**
+     * Block role: `"receiver"` or `"satellite"`.
+     */
+    readonly kind: string;
+    /**
+     * ANTEX serial, PRN, or radome field.
+     */
+    readonly serial: string;
+    /**
+     * Optional SINEX calibration code.
+     */
+    readonly sinexCode: string | undefined;
+    /**
+     * First valid timestamp, or `undefined` for an open-ended block.
+     */
+    readonly validFrom: AntexDateTime | undefined;
+    /**
+     * Last valid timestamp, or `undefined` for an open-ended block.
+     */
+    readonly validUntil: AntexDateTime | undefined;
+    /**
+     * Zenith grid end angle, degrees.
+     */
+    readonly zenithEndDeg: number;
+    /**
+     * Zenith grid start angle, degrees.
+     */
+    readonly zenithStartDeg: number;
+    /**
+     * Zenith grid step, degrees.
+     */
+    readonly zenithStepDeg: number;
+}
+
+/**
+ * A parsed ANTEX receiver and satellite antenna calibration product.
+ */
+export class Antex {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Return an antenna by exact `TYPE / SERIAL` id, or `undefined`.
+     */
+    antenna(id: string): Antenna | undefined;
+    /**
+     * Return the satellite antenna for `prn` valid at `epoch`, or `undefined`.
+     */
+    satelliteAntenna(prn: string, epoch: AntexDateTime): Antenna | undefined;
+    /**
+     * Number of antenna blocks parsed from the product.
+     */
+    readonly antennaCount: number;
+    /**
+     * ANTEX `TYPE / SERIAL` ids in deterministic order.
+     */
+    readonly antennaIds: string[];
+}
+
+/**
+ * A civil UTC-like ANTEX validity timestamp.
+ */
+export class AntexDateTime {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create an ANTEX validity timestamp. `hour` / `minute` / `second` default
+     * to 0. Throws a `RangeError` on an invalid date.
+     */
+    constructor(year: number, month: number, day: number, hour?: number | null, minute?: number | null, second?: number | null);
+    /**
+     * Calendar day of month.
+     */
+    readonly day: number;
+    /**
+     * Hour of day.
+     */
+    readonly hour: number;
+    /**
+     * Minute of hour.
+     */
+    readonly minute: number;
+    /**
+     * Calendar month, 1..=12.
+     */
+    readonly month: number;
+    /**
+     * Second of minute.
+     */
+    readonly second: number;
+    /**
+     * Calendar year.
+     */
+    readonly year: number;
+}
+
+/**
+ * Result of applying base corrections to rover observations.
+ */
+export class AppliedCorrections {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Corrected rover observations as `{ satelliteId, pseudorangeM }[]`, in
+     * rover-observation order.
+     */
+    readonly corrected: any;
+    /**
+     * Rover satellite tokens with no matching base correction, in rover order.
+     */
+    readonly dropped: string[];
+}
+
+/**
+ * A parsed broadcast ephemeris store from a RINEX NAV file. `records` are the
+ * usable GPS/Galileo/BeiDou records selected by the core default SPP policy.
+ */
+export class BroadcastEphemeris {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compare this broadcast product against a precise SP3 product over a
+     * J2000-second window `[fromJ2000S, toJ2000S]` at `stepS`.
+     *
+     * `satellites` is the list of tokens (e.g. `["G01", "G11"]`) to compare. The
+     * per-epoch keys are built here: the broadcast query second is the epoch
+     * itself, and the precise queries use the SP3 split Julian dates at the
+     * epoch and at `epoch +/- round(stepS / 2)` for the centered velocity
+     * difference. Returns a `{ overall, perSatellite, missing }` report; metre
+     * fields are `null` where no compared epoch populated them.
+     */
+    compareToSp3(precise: Sp3, satellites: string[], from_j2000_s: number, to_j2000_s: number, step_s: number): any;
+    /**
+     * Solve a receiver position from broadcast ephemeris ALONE: the supported
+     * real-time / offline single-point-positioning mode. `request` is the same
+     * SPP request object [`Sp3.solveSpp`] takes. The result is identical to
+     * solving against this broadcast store as an ephemeris source.
+     */
+    solveBroadcast(request: any): SppSolution;
+    /**
+     * Number of usable GLONASS records.
+     */
+    readonly glonassRecordCount: number;
+    /**
+     * Healthy GLONASS broadcast records in file order.
+     */
+    readonly glonassRecords: GlonassRecordJs[];
+    /**
+     * Broadcast ionosphere coefficients parsed from the NAV header.
+     */
+    readonly ionoCorrections: IonoCorrectionsJs;
+    /**
+     * GPS minus UTC leap seconds from the NAV header, or `undefined`.
+     */
+    readonly leapSeconds: number | undefined;
+    /**
+     * Number of usable GPS, Galileo, and BeiDou records.
+     */
+    readonly recordCount: number;
+    /**
+     * Usable GPS, Galileo, and BeiDou broadcast records in file order.
+     */
+    readonly records: BroadcastRecordJs[];
+}
+
+/**
+ * Evaluated broadcast orbit and satellite clock at one seconds-of-week epoch.
+ */
+export class BroadcastEvaluation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Broadcast clock-polynomial component, seconds.
+     */
+    readonly clockPolynomialS: number;
+    /**
+     * Total satellite clock offset, seconds.
+     */
+    readonly clockS: number;
+    /**
+     * Broadcast group delay subtracted from the clock offset, seconds.
+     */
+    readonly groupDelayS: number;
+    /**
+     * Fixed-point iterations used to solve Kepler's equation.
+     */
+    readonly keplerIterations: number;
+    /**
+     * ITRF/ECEF satellite position `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Relativistic eccentricity clock component, seconds.
+     */
+    readonly relativisticClockS: number;
+    /**
+     * Query epoch, seconds of week in the record's broadcast time scale.
+     */
+    readonly tSowS: number;
+    /**
+     * ITRF/ECEF X, metres.
+     */
+    readonly xM: number;
+    /**
+     * ITRF/ECEF Y, metres.
+     */
+    readonly yM: number;
+    /**
+     * ITRF/ECEF Z, metres.
+     */
+    readonly zM: number;
+}
+
+/**
+ * One GPS, Galileo, or BeiDou broadcast ephemeris record from RINEX NAV.
+ */
+export class BroadcastRecordJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Evaluate the broadcast record at a seconds-of-week epoch. `tSowS` is in
+     * the record's broadcast time scale. Throws a `RangeError` on a non-finite
+     * epoch and an `Error` if the orbit cannot be evaluated.
+     */
+    evaluate(t_sow_s: number): BroadcastEvaluation;
+    /**
+     * Satellite clock polynomial.
+     */
+    readonly clock: ClockPolynomialJs;
+    /**
+     * Keplerian orbital elements in SI units.
+     */
+    readonly elements: KeplerianElementsJs;
+    /**
+     * GPS curve-fit interval, seconds, or `undefined` when not broadcast.
+     */
+    readonly fitIntervalS: number | undefined;
+    /**
+     * Broadcast group delay, seconds.
+     */
+    readonly groupDelayS: number;
+    /**
+     * Broadcast message type.
+     */
+    readonly message: NavMessage;
+    /**
+     * RINEX satellite token such as `"G01"`.
+     */
+    readonly satellite: string;
+    /**
+     * Signal-in-space accuracy, metres.
+     */
+    readonly svAccuracyM: number;
+    /**
+     * Satellite health word; 0 is healthy for nominal GPS/Galileo.
+     */
+    readonly svHealth: number;
+    /**
+     * Continuous constellation week number from the broadcast record.
+     */
+    readonly week: number;
+}
+
+/**
+ * A canonical GNSS carrier band. The JS value matches the variant order below.
+ */
+export enum CarrierBand {
+    /**
+     * GPS/QZSS L1.
+     */
+    L1 = 0,
+    /**
+     * GPS/QZSS L2.
+     */
+    L2 = 1,
+    /**
+     * GPS/QZSS L5.
+     */
+    L5 = 2,
+    /**
+     * Galileo E1.
+     */
+    E1 = 3,
+    /**
+     * Galileo E5a.
+     */
+    E5a = 4,
+    /**
+     * Galileo E5b.
+     */
+    E5b = 5,
+    /**
+     * Galileo E5 AltBOC.
+     */
+    E5 = 6,
+    /**
+     * Galileo E6.
+     */
+    E6 = 7,
+    /**
+     * BeiDou B1C.
+     */
+    B1c = 8,
+    /**
+     * BeiDou B1I.
+     */
+    B1i = 9,
+    /**
+     * BeiDou B2a.
+     */
+    B2a = 10,
+    /**
+     * BeiDou B2b.
+     */
+    B2b = 11,
+    /**
+     * BeiDou B2.
+     */
+    B2 = 12,
+    /**
+     * BeiDou B3I.
+     */
+    B3i = 13,
+    /**
+     * GLONASS G1 FDMA.
+     */
+    G1 = 14,
+    /**
+     * GLONASS G2 FDMA.
+     */
+    G2 = 15,
+}
+
+/**
+ * A standard two-carrier ionosphere-free pair.
+ */
+export class CarrierPair {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a two-carrier pair.
+     */
+    constructor(band1: CarrierBand, band2: CarrierBand);
+    /**
+     * First carrier band.
+     */
+    readonly band1: CarrierBand;
+    /**
+     * Second carrier band.
+     */
+    readonly band2: CarrierBand;
+}
+
+/**
+ * Flattened carrier-phase rows from one RINEX OBS epoch. Numeric arrays are
+ * row-aligned with `satellites` and `codes`; missing values and unknown
+ * carrier metadata are `NaN`.
+ */
+export class CarrierPhaseSeries {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * RINEX carrier observation codes, row-aligned with all arrays.
+     */
+    readonly codes: string[];
+    /**
+     * Carrier frequency, hertz.
+     */
+    readonly frequencyHz: Float64Array;
+    /**
+     * Number of flattened rows.
+     */
+    readonly length: number;
+    /**
+     * RINEX LLI values, `NaN` for blanks.
+     */
+    readonly lli: Float64Array;
+    /**
+     * Applied phase shift, cycles.
+     */
+    readonly phaseShiftCycles: Float64Array;
+    /**
+     * Satellite tokens, row-aligned with all arrays.
+     */
+    readonly satellites: string[];
+    /**
+     * RINEX SSI values, `NaN` for blanks.
+     */
+    readonly ssi: Float64Array;
+    /**
+     * Carrier phase, cycles.
+     */
+    readonly valueCycles: Float64Array;
+    /**
+     * Carrier phase, metres.
+     */
+    readonly valueM: Float64Array;
+    /**
+     * Carrier wavelength, metres.
+     */
+    readonly wavelengthM: Float64Array;
+}
+
+/**
+ * A two-object CCSDS Conjunction Data Message parsed from KVN or XML.
+ */
+export class Cdm {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a CDM from two objects. `meta` carries the optional message-level
+     * fields.
+     */
+    constructor(object1: CdmObject, object2: CdmObject, meta: any);
+    /**
+     * Encode this message to CCSDS CDM KVN text.
+     */
+    toKvnString(): string;
+    /**
+     * Encode this message to CCSDS CDM XML text.
+     */
+    toXmlString(): string;
+    /**
+     * Collision probability.
+     */
+    readonly collisionProbability: number | undefined;
+    /**
+     * Collision-probability method label.
+     */
+    readonly collisionProbabilityMethod: string | undefined;
+    /**
+     * Creation date.
+     */
+    readonly creationDate: string | undefined;
+    /**
+     * Hard-body radius, metres.
+     */
+    readonly hardBodyRadiusM: number | undefined;
+    /**
+     * Message id.
+     */
+    readonly messageId: string | undefined;
+    /**
+     * Miss distance, metres.
+     */
+    readonly missDistanceM: number | undefined;
+    /**
+     * First object.
+     */
+    readonly object1: CdmObject;
+    /**
+     * Second object.
+     */
+    readonly object2: CdmObject;
+    /**
+     * Originator.
+     */
+    readonly originator: string | undefined;
+    /**
+     * Relative speed, m/s.
+     */
+    readonly relativeSpeedMS: number | undefined;
+    /**
+     * Time of closest approach (TCA).
+     */
+    readonly tca: string | undefined;
+}
+
+/**
+ * One object's metadata, state vector, and RTN position covariance from a CDM.
+ */
+export class CdmObject {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a CDM object. `positionKm` / `velocityKmS` are length-3
+     * `Float64Array`s; `covarianceRtn` is the length-6 RTN lower triangle
+     * `[CR_R, CT_R, CT_T, CN_R, CN_T, CN_N]`. `meta` carries the optional
+     * string fields.
+     */
+    constructor(position_km: Float64Array, velocity_km_s: Float64Array, covariance_rtn: Float64Array, meta: any);
+    /**
+     * Catalog name.
+     */
+    readonly catalogName: string | undefined;
+    /**
+     * RTN position-covariance lower triangle, length-6 `Float64Array`.
+     */
+    readonly covarianceRtn: Float64Array;
+    /**
+     * International designator (COSPAR ID).
+     */
+    readonly internationalDesignator: string | undefined;
+    /**
+     * Object designator.
+     */
+    readonly objectDesignator: string | undefined;
+    /**
+     * Object name.
+     */
+    readonly objectName: string | undefined;
+    /**
+     * Object type.
+     */
+    readonly objectType: string | undefined;
+    /**
+     * Position vector, kilometres, length-3 `Float64Array`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * Reference frame.
+     */
+    readonly refFrame: string | undefined;
+    /**
+     * Velocity vector, km/s, length-3 `Float64Array`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * An advisory TLE checksum discrepancy. The TLE grammar does not reject a line
+ * on a bad modulo-10 checksum, so each mismatch is surfaced here rather than
+ * thrown.
+ */
+export class ChecksumWarning {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The checksum digit recomputed from columns 1-68.
+     */
+    readonly computed: number;
+    /**
+     * The checksum digit found in column 69 of the line.
+     */
+    readonly expected: number;
+    /**
+     * Which line the discrepancy is on: `"line 1"` or `"line 2"`.
+     */
+    readonly lineLabel: string;
+}
+
+/**
+ * A civil GPS-time epoch for RINEX clock interpolation. Calendar fields are
+ * interpreted in GPS time; `gpsSeconds` is seconds since 1980-01-06 GPST.
+ */
+export class ClockEpoch {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a GPS-time civil epoch. Throws a `RangeError` for invalid fields.
+     */
+    constructor(year: number, month: number, day: number, hour: number, minute: number, second: number);
+    readonly day: number;
+    /**
+     * Seconds since the GPS epoch, 1980-01-06 00:00:00 GPST.
+     */
+    readonly gpsSeconds: number;
+    readonly hour: number;
+    readonly minute: number;
+    readonly month: number;
+    readonly second: number;
+    readonly year: number;
+}
+
+/**
+ * Broadcast satellite-clock polynomial. `af0`/`af1`/`af2` are s, s/s, s/s^2;
+ * `tocSow` is seconds of week.
+ */
+export class ClockPolynomialJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly af0: number;
+    readonly af1: number;
+    readonly af2: number;
+    readonly tocSow: number;
+}
+
+/**
+ * Per-satellite RINEX clock-bias samples. `gpsSeconds` and `biasS` are
+ * row-aligned `Float64Array`s; epochs are GPS seconds, biases are seconds.
+ */
+export class ClockSeries {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Satellite clock-bias samples, seconds, as a `Float64Array`.
+     */
+    readonly biasS: Float64Array;
+    /**
+     * Sample times, GPS seconds, as a `Float64Array`.
+     */
+    readonly gpsSeconds: Float64Array;
+    /**
+     * Number of clock samples for this satellite.
+     */
+    readonly length: number;
+    /**
+     * RINEX satellite token such as `"G05"`.
+     */
+    readonly satellite: string;
+}
+
+/**
+ * Collision-probability result and encounter-plane summary.
+ */
+export class CollisionProbability {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Orthogonal miss distance in the encounter plane, km.
+     */
+    readonly missKm: number;
+    /**
+     * Collision probability.
+     */
+    readonly pc: number;
+    /**
+     * Relative speed, km/s.
+     */
+    readonly relativeSpeedKmS: number;
+    /**
+     * Principal-axis standard deviation in the encounter plane, km.
+     */
+    readonly sigmaXKm: number;
+    /**
+     * Principal-axis standard deviation in the encounter plane, km.
+     */
+    readonly sigmaZKm: number;
+}
+
+/**
+ * One object's conjunction state: ECI position (km), velocity (km/s), and 3x3
+ * position covariance (km^2, flat row-major length 9).
+ */
+export class ConjunctionState {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a conjunction state. `positionKm` and `velocityKmS` are length-3
+     * `Float64Array`s; `covarianceKm2` is a flat row-major length-9
+     * `Float64Array`.
+     */
+    constructor(position_km: Float64Array, velocity_km_s: Float64Array, covariance_km2: Float64Array);
+    /**
+     * Position covariance, km^2, as a flat row-major length-9 `Float64Array`.
+     */
+    readonly covarianceKm2: Float64Array;
+    /**
+     * ECI position, kilometres, as a length-3 `Float64Array`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * ECI velocity, km/s, as a length-3 `Float64Array`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * Coherent GPS C/A correlation result.
+ */
+export class CorrelationResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * In-phase coherent sum.
+     */
+    readonly i: number;
+    /**
+     * Squared magnitude, `i*i + q*q`.
+     */
+    readonly power: number;
+    /**
+     * Quadrature coherent sum.
+     */
+    readonly q: number;
+}
+
+/**
+ * A DGNSS rover solve: the corrected SPP solution plus the base-relative
+ * baseline.
+ */
+export class DgnssSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Baseline length, metres.
+     */
+    readonly baselineM: number;
+    /**
+     * Rover-minus-base ECEF vector `[dx, dy, dz]`, metres.
+     */
+    readonly baselineVectorM: Float64Array;
+    /**
+     * Rover satellite tokens without a matching base correction.
+     */
+    readonly droppedSats: string[];
+    /**
+     * `[latRad, lonRad, heightM]` when the solve was asked for geodetic output.
+     */
+    readonly geodetic: Float64Array | undefined;
+    /**
+     * Corrected rover ECEF position `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Post-fit residuals, metres, index-aligned to `usedSats`.
+     */
+    readonly residualsM: Float64Array;
+    /**
+     * Receiver clock bias, seconds (absorbs the base/rover clock difference).
+     */
+    readonly rxClockS: number;
+    /**
+     * Satellite tokens used in the accepted solution, ascending.
+     */
+    readonly usedSats: string[];
+}
+
+/**
+ * GNSS dilution-of-precision scalars.
+ */
+export class Dop {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute DOP from topocentric azimuth/elevation rows.
+     *
+     * `azimuthDeg` and `elevationDeg` are `Float64Array`s of length `n`
+     * (azimuth clockwise from geodetic north). `receiver` defines the local ENU
+     * frame. Optional `weights` is a positive `Float64Array` of length `n`.
+     */
+    static fromAzEl(azimuth_deg: Float64Array, elevation_deg: Float64Array, receiver: Wgs84Geodetic, weights?: Float64Array | null): Dop;
+    /**
+     * Compute DOP from ECEF line-of-sight unit rows.
+     *
+     * `lineOfSight` is a flat row-major `(n, 3)` `Float64Array` of ECEF unit
+     * vectors, `receiver` is WGS84 geodetic, optional `weights` is a positive
+     * `Float64Array` of length `n`. At least four rows are required.
+     */
+    static fromLineOfSight(line_of_sight: Float64Array, receiver: Wgs84Geodetic, weights?: Float64Array | null): Dop;
+    /**
+     * Geometric DOP.
+     */
+    readonly gdop: number;
+    /**
+     * Horizontal DOP.
+     */
+    readonly hdop: number;
+    /**
+     * Position DOP.
+     */
+    readonly pdop: number;
+    /**
+     * Time DOP.
+     */
+    readonly tdop: number;
+    /**
+     * Vertical DOP.
+     */
+    readonly vdop: number;
+}
+
+/**
+ * DOP values sampled from an SP3 precise product over an epoch grid. Only
+ * samples with finite DOP are retained.
+ */
+export class DopSeries {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Satellite tokens used at finite sample `index`, ascending in elevation.
+     */
+    satellitesAt(index: number): string[] | undefined;
+    /**
+     * Number of finite DOP samples.
+     */
+    readonly epochCount: number;
+    /**
+     * Geometric DOP samples, `Float64Array`.
+     */
+    readonly gdop: Float64Array;
+    /**
+     * Horizontal DOP samples, `Float64Array`.
+     */
+    readonly hdop: Float64Array;
+    /**
+     * Successful sample epochs, seconds since J2000, `Float64Array`.
+     */
+    readonly j2000Seconds: Float64Array;
+    /**
+     * Position DOP samples, `Float64Array`.
+     */
+    readonly pdop: Float64Array;
+    /**
+     * Number of satellites used at each finite sample, `Int32Array`.
+     */
+    readonly satelliteCount: Int32Array;
+    /**
+     * Input epoch indices for finite DOP samples, `Int32Array`.
+     */
+    readonly stepIndex: Int32Array;
+    /**
+     * Time DOP samples, `Float64Array`.
+     */
+    readonly tdop: Float64Array;
+    /**
+     * Vertical DOP samples, `Float64Array`.
+     */
+    readonly vdop: Float64Array;
+}
+
+/**
+ * Orthonormal encounter frame built from two relative states.
+ */
+export class EncounterFrame {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Orthogonal miss distance in the encounter plane, km.
+     */
+    readonly missKm: number;
+    /**
+     * Relative position (object2 minus object1), km, length-3 `Float64Array`.
+     */
+    readonly relativePositionKm: Float64Array;
+    /**
+     * Relative speed, km/s.
+     */
+    readonly relativeSpeedKmS: number;
+    /**
+     * Relative velocity (object2 minus object1), km/s, length-3 `Float64Array`.
+     */
+    readonly relativeVelocityKmS: Float64Array;
+    /**
+     * In-plane cross-track unit axis, length-3 `Float64Array`.
+     */
+    readonly xHat: Float64Array;
+    /**
+     * Relative-velocity unit axis, length-3 `Float64Array`.
+     */
+    readonly yHat: Float64Array;
+    /**
+     * Encounter-plane normal unit axis, length-3 `Float64Array`.
+     */
+    readonly zHat: Float64Array;
+}
+
+/**
+ * An ephemeris from numerical state-vector propagation: the requested output
+ * epochs plus the Cartesian state at each. Arrays are flat row-major.
+ */
+export class Ephemeris {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of output epochs.
+     */
+    readonly epochCount: number;
+    /**
+     * ECI positions, km, flat `[x0, y0, z0, x1, ...]`, length `3 * epochCount`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * The full state ephemeris as a flat row-major `Float64Array` of length
+     * `6 * epochCount`, each row `[x, y, z, vx, vy, vz]` (km, km/s).
+     */
+    readonly states: Float64Array;
+    /**
+     * The output epochs (TDB seconds), as a `Float64Array` of length `epochCount`.
+     */
+    readonly timesS: Float64Array;
+    /**
+     * ECI velocities, km/s, flat `[vx0, vy0, vz0, ...]`, length `3 * epochCount`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * A fault-detection-and-exclusion result: the surviving solution, the excluded
+ * satellites in exclusion order, and the number of exclusions performed.
+ */
+export class FdeSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Excluded satellite tokens, in the order RAIM removed them.
+     */
+    readonly excluded: string[];
+    /**
+     * `[latRad, lonRad, heightM]` when geodetic output was requested.
+     */
+    readonly geodetic: Float64Array | undefined;
+    /**
+     * Number of exclusions performed before the set passed RAIM.
+     */
+    readonly iterations: number;
+    /**
+     * Surviving-solution ECEF position `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Post-fit residuals, metres, index-aligned to `usedSats`.
+     */
+    readonly residualsM: Float64Array;
+    /**
+     * Receiver clock bias, seconds.
+     */
+    readonly rxClockS: number;
+    /**
+     * Satellite tokens used in the surviving solution, ascending.
+     */
+    readonly usedSats: string[];
+}
+
+/**
+ * A batch of transformed states from [`temeToGcrs`]: flat row-major
+ * `positionKm` and `velocityKmS` `Float64Array`s, each length `3 * epochCount`.
+ */
+export class FrameStates {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of states in the batch.
+     */
+    readonly epochCount: number;
+    /**
+     * Transformed positions, kilometres, flat row-major `(n, 3)`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * Transformed velocities, km/s, flat row-major `(n, 3)`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * One GLONASS broadcast state-vector record. `toeUtcJ2000S` is UTC seconds past
+ * J2000; position is PZ-90.11 ECEF metres, velocity m/s, acceleration m/s^2.
+ */
+export class GlonassRecordJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Lunisolar acceleration `[ax, ay, az]`, metres per second squared.
+     */
+    readonly accelerationMS2: Float64Array;
+    /**
+     * Broadcast clock bias, seconds.
+     */
+    readonly clockBiasS: number;
+    /**
+     * FDMA frequency-channel number.
+     */
+    readonly freqChannel: number;
+    /**
+     * Relative frequency offset.
+     */
+    readonly gammaN: number;
+    /**
+     * PZ-90.11 ECEF position `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * RINEX satellite token such as `"R10"`.
+     */
+    readonly satellite: string;
+    /**
+     * Satellite health; 0 is healthy.
+     */
+    readonly svHealth: number;
+    /**
+     * Reference epoch, UTC seconds past J2000.
+     */
+    readonly toeUtcJ2000S: number;
+    /**
+     * PZ-90.11 ECEF velocity `[vx, vy, vz]`, metres per second.
+     */
+    readonly velocityMS: Float64Array;
+}
+
+/**
+ * A GNSS constellation. The JS value matches the variant order below.
+ */
+export enum GnssSystem {
+    /**
+     * GPS, RINEX letter `G`.
+     */
+    Gps = 0,
+    /**
+     * GLONASS, RINEX letter `R`.
+     */
+    Glonass = 1,
+    /**
+     * Galileo, RINEX letter `E`.
+     */
+    Galileo = 2,
+    /**
+     * BeiDou, RINEX letter `C`.
+     */
+    BeiDou = 3,
+    /**
+     * QZSS, RINEX letter `J`.
+     */
+    Qzss = 4,
+    /**
+     * NavIC, RINEX letter `I`.
+     */
+    Navic = 5,
+    /**
+     * SBAS, RINEX letter `S`.
+     */
+    Sbas = 6,
+}
+
+/**
+ * A GNSS week number plus time-of-week, tagged by constellation.
+ */
+export class GnssWeekTow {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a week/TOW. Throws a `RangeError` on an invalid value.
+     */
+    constructor(system: TimeScale, week: number, tow_s: number);
+    /**
+     * Normalize so `towS` lands in `[0, 604800)`, carrying whole weeks into
+     * `week`. Negative `towS` borrows from the week count.
+     */
+    normalized(): GnssWeekTow;
+    /**
+     * Apply a 1024-week rollover count to recover the continuous week number.
+     */
+    unrolledWeek(rollovers: number): number;
+    /**
+     * The constellation/system whose week/TOW convention this uses.
+     */
+    readonly system: TimeScale;
+    /**
+     * Time of week, seconds, nominally `[0, 604800)`.
+     */
+    readonly towS: number;
+    /**
+     * Week number (constellation-native, may have rolled over).
+     */
+    readonly week: number;
+}
+
+/**
+ * A geodetic ground station: WGS84 latitude/longitude in degrees, altitude in
+ * metres. Pass to [`Tle.lookAngles`] / [`Tle.findPasses`].
+ */
+export class GroundStation {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create a ground station. `altitudeM` defaults to 0.
+     */
+    constructor(latitude_deg: number, longitude_deg: number, altitude_m?: number | null);
+    readonly altitudeM: number;
+    readonly latitudeDeg: number;
+    readonly longitudeDeg: number;
+}
+
+/**
+ * A point in time, tagged UTC, with the precise time scales resolved.
+ *
+ * Construct from a unix-microsecond UTC stamp (a `bigint`) or from UTC calendar
+ * fields. The resolved TT/UT1/TDB Julian dates, sidereal time, and
+ * precession/nutation are exposed as read-only properties and methods, all from
+ * the engine's parity-critical pipeline.
+ */
+export class Instant {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an instant from a unix-microsecond UTC stamp.
+     */
+    static fromUnixMicros(unix_micros: bigint): Instant;
+    /**
+     * Build an instant from UTC calendar fields. `second` may be fractional and
+     * is held to microsecond resolution. Throws a `RangeError` on an
+     * out-of-range calendar field.
+     */
+    static fromUtc(year: number, month: number, day: number, hour?: number | null, minute?: number | null, second?: number | null): Instant;
+    /**
+     * Greenwich Apparent Sidereal Time, radians in `[0, 2pi)`.
+     */
+    gastRadians(): number;
+    /**
+     * Greenwich Mean Sidereal Time, radians in `[0, 2pi)`.
+     */
+    gmstRadians(): number;
+    /**
+     * IAU 2000A nutation in longitude and obliquity `[dpsi, deps]`, radians,
+     * as a `Float64Array` of length 2.
+     */
+    nutationAngles(): Float64Array;
+    /**
+     * IAU 2000A nutation rotation matrix as a flat row-major `Float64Array` of
+     * length 9 (3-by-3).
+     */
+    nutationMatrix(): Float64Array;
+    /**
+     * IAU 2006 precession rotation matrix as a flat row-major `Float64Array` of
+     * length 9 (3-by-3).
+     */
+    precessionMatrix(): Float64Array;
+    /**
+     * Delta-T (TT minus UT1), seconds.
+     */
+    readonly deltaTSeconds: number;
+    /**
+     * The shared integer Julian-day boundary (TAI-aligned).
+     */
+    readonly jdWhole: number;
+    /**
+     * IAU mean obliquity of the ecliptic, radians.
+     */
+    readonly meanObliquityRadians: number;
+    /**
+     * TDB day fraction relative to `jdWhole`.
+     */
+    readonly tdbFraction: number;
+    /**
+     * Full Barycentric Dynamical Time (TDB) Julian date.
+     */
+    readonly tdbJd: number;
+    /**
+     * The two-part TDB Julian date (`jdWhole`, `tdbFraction`).
+     */
+    readonly tdbJdSplit: JulianDate;
+    /**
+     * TT day fraction relative to `jdWhole`.
+     */
+    readonly ttFraction: number;
+    /**
+     * Full Terrestrial Time (TT) Julian date.
+     */
+    readonly ttJd: number;
+    /**
+     * The two-part TT Julian date (`jdWhole`, `ttFraction`).
+     */
+    readonly ttJdSplit: JulianDate;
+    /**
+     * The unix-microsecond UTC stamp backing this instant.
+     */
+    readonly unixMicros: bigint;
+    /**
+     * UT1 day fraction relative to `jdWhole`.
+     */
+    readonly ut1Fraction: number;
+    /**
+     * Full UT1 Julian date.
+     */
+    readonly ut1Jd: number;
+    /**
+     * The two-part UT1 Julian date (`jdWhole`, `ut1Fraction`).
+     */
+    readonly ut1JdSplit: JulianDate;
+}
+
+/**
+ * A parsed IONEX vertical-TEC product. Create with [`load_ionex`].
+ */
+export class Ionex {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * IONEX slant ionospheric group delay, positive metres.
+     *
+     * Receiver latitude/longitude and satellite azimuth/elevation are degrees
+     * (latitude positive north, longitude positive east, azimuth clockwise
+     * from north). The pierce point rides on the IONEX shell, so no receiver
+     * height enters. `epochJ2000S` is an integer number of seconds since J2000.
+     * `frequencyHz` is the carrier the dispersive delay is reported on. Throws
+     * a `RangeError` on non-finite input and an `Error` on out-of-range input.
+     */
+    slantDelay(lat_deg: number, lon_deg: number, azimuth_deg: number, elevation_deg: number, epoch_j2000_s: number, frequency_hz: number): number;
+    /**
+     * Mean Earth radius used by the geometry, kilometres.
+     */
+    readonly baseRadiusKm: number;
+    /**
+     * The IONEX `EXPONENT` header field; the TEC scale is `10^exponent`.
+     */
+    readonly exponent: number;
+    /**
+     * Latitude node values, degrees, as a `Float64Array`, descending
+     * (north-to-south).
+     */
+    readonly latNodesDeg: Float64Array;
+    /**
+     * Longitude node values, degrees, as a `Float64Array`, ascending
+     * (west-to-east).
+     */
+    readonly lonNodesDeg: Float64Array;
+    /**
+     * Map epochs as seconds since J2000, ascending, as a `Float64Array`. This
+     * is the exact axis [`Ionex.slantDelay`] brackets against.
+     */
+    readonly mapEpochsJ2000S: Float64Array;
+    /**
+     * Single-layer shell height, kilometres.
+     */
+    readonly shellHeightKm: number;
+}
+
+/**
+ * A staleness-selected IONEX product plus its [`StalenessMetadata`]. The inner
+ * product is the present product for an exact selection or a diurnal-shifted
+ * copy for a degraded one; either way `slantDelay` evaluates the standard slant
+ * delay on it.
+ */
+export class IonexSelection {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Slant ionospheric group delay, positive metres, from the selected product.
+     * Same degree-valued geometry as [`Ionex.slantDelay`]; for an exact
+     * selection the result is bit-for-bit identical to evaluating the caller's
+     * product directly.
+     */
+    slantDelay(lat_deg: number, lon_deg: number, azimuth_deg: number, elevation_deg: number, epoch_j2000_s: number, frequency_hz: number): number;
+    /**
+     * The usable IONEX product as a standalone [`Ionex`] handle: the present
+     * product for an exact selection, or the diurnal-shifted copy.
+     */
+    readonly ionex: Ionex;
+    /**
+     * The staleness metadata as a plain object (see [`StalenessMetadataJs`]).
+     */
+    readonly metadata: any;
+}
+
+/**
+ * Broadcast ionosphere coefficients parsed from a RINEX NAV header.
+ */
+export class IonoCorrectionsJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * BeiDou Klobuchar coefficients, if the header has BDSA and BDSB.
+     */
+    readonly beidou: KlobucharAlphaBetaJs | undefined;
+    /**
+     * GPS Klobuchar coefficients, if the header has GPSA and GPSB.
+     */
+    readonly gps: KlobucharAlphaBetaJs | undefined;
+}
+
+/**
+ * Result of combining two pseudorange bands into ionosphere-free ranges.
+ */
+export class IonoFreePseudorangeResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Combined ionosphere-free ranges, metres, row-aligned with `combinedSats`.
+     */
+    readonly combinedM: Float64Array;
+    /**
+     * Satellite tokens with a combined ionosphere-free range, sorted.
+     */
+    readonly combinedSats: string[];
+    /**
+     * Drop reasons row-aligned with `droppedSats`.
+     */
+    readonly droppedReasons: any[];
+    /**
+     * Satellite tokens dropped from the combination, sorted.
+     */
+    readonly droppedSats: string[];
+}
+
+/**
+ * Hatch-smoothed ionosphere-free code output for one epoch.
+ */
+export class IonoFreeSmoothResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Instantaneous ionosphere-free carrier phase, metres, or `undefined`.
+     */
+    readonly lIfM: number | undefined;
+    /**
+     * Instantaneous ionosphere-free code, metres, or `undefined`.
+     */
+    readonly pIfM: number | undefined;
+    /**
+     * Smoothed ionosphere-free code pseudorange, metres, or `undefined`.
+     */
+    readonly pSmoothM: number | undefined;
+    /**
+     * True when a prior running window was reset by a slip.
+     */
+    readonly reset: boolean;
+    /**
+     * Hatch window length used at this epoch.
+     */
+    readonly window: number;
+}
+
+/**
+ * A two-part Julian date: an integer-day boundary plus a residual fraction,
+ * preserving sub-microsecond precision across the Julian-date range.
+ */
+export class JulianDate {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Residual day fraction relative to `whole`.
+     */
+    readonly fraction: number;
+    /**
+     * The recombined single-`number` Julian date (`whole + fraction`).
+     */
+    readonly jd: number;
+    /**
+     * Integer-day boundary (typically `*.0` or `*.5`).
+     */
+    readonly whole: number;
+}
+
+/**
+ * Broadcast Keplerian orbital elements. Units are SI: angles in radians,
+ * correction terms in radians or metres, `toeSow` in seconds of week.
+ */
+export class KeplerianElementsJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly cic: number;
+    readonly cis: number;
+    readonly crc: number;
+    readonly crs: number;
+    readonly cuc: number;
+    readonly cus: number;
+    readonly deltaN: number;
+    readonly e: number;
+    readonly i0: number;
+    readonly idot: number;
+    readonly m0: number;
+    readonly omega: number;
+    readonly omega0: number;
+    readonly omegaDot: number;
+    readonly sqrtA: number;
+    readonly toeSow: number;
+}
+
+/**
+ * Klobuchar alpha and beta ionosphere coefficients (each a 4-element array).
+ */
+export class KlobucharAlphaBetaJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Alpha coefficients as a `Float64Array` of length 4.
+     */
+    readonly alpha: Float64Array;
+    /**
+     * Beta coefficients as a `Float64Array` of length 4.
+     */
+    readonly beta: Float64Array;
+}
+
+/**
+ * Provenance and coverage of the embedded IERS leap-second (TAI-UTC) table.
+ */
+export class LeapSecondTable {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of entries in the table.
+     */
+    readonly entries: number;
+    /**
+     * Modified Julian date of the first table entry.
+     */
+    readonly firstMjd: number;
+    /**
+     * Modified Julian date of the last table entry.
+     */
+    readonly lastMjd: number;
+    /**
+     * Human-readable provenance string for the table.
+     */
+    readonly source: string;
+}
+
+/**
+ * Link-budget inputs for [`LinkBudget.margin`].
+ */
+export class LinkBudget {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a link-budget input object. `otherLossesDb` defaults to 0. Throws a
+     * `RangeError` on a non-finite field.
+     */
+    constructor(eirp_dbw: number, fspl_db: number, receiver_gt_dbk: number, required_cn0_dbhz: number, other_losses_db?: number | null);
+    /**
+     * Transmitter EIRP, dBW.
+     */
+    readonly eirpDbw: number;
+    /**
+     * Free-space path loss, dB.
+     */
+    readonly fsplDb: number;
+    /**
+     * Link margin, dB, for this budget.
+     */
+    readonly margin: number;
+    /**
+     * Sum of miscellaneous losses, dB.
+     */
+    readonly otherLossesDb: number;
+    /**
+     * Receiver figure of merit G/T, dB/K.
+     */
+    readonly receiverGtDbk: number;
+    /**
+     * Required C/N0 threshold, dB-Hz.
+     */
+    readonly requiredCn0Dbhz: number;
+}
+
+/**
+ * Topocentric look angles from a batched arc, each a `Float64Array` of length
+ * `epochCount`.
+ */
+export class LookAngles {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Azimuth, degrees clockwise from north.
+     */
+    readonly azimuthDeg: Float64Array;
+    /**
+     * Elevation, degrees above the horizon.
+     */
+    readonly elevationDeg: Float64Array;
+    /**
+     * Number of epochs evaluated.
+     */
+    readonly epochCount: number;
+    /**
+     * Slant range, kilometres.
+     */
+    readonly rangeKm: Float64Array;
+}
+
+/**
+ * Niell hydrostatic and wet mapping factors, dimensionless.
+ */
+export class MappingFactors {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Hydrostatic mapping factor (includes the height correction).
+     */
+    readonly dry: number;
+    /**
+     * Wet mapping factor.
+     */
+    readonly wet: number;
+}
+
+/**
+ * Which supported RINEX NAV message a broadcast record carries.
+ */
+export enum NavMessage {
+    /**
+     * GPS legacy LNAV.
+     */
+    GpsLnav = 0,
+    /**
+     * Galileo I/NAV.
+     */
+    GalileoInav = 1,
+    /**
+     * Galileo F/NAV.
+     */
+    GalileoFnav = 2,
+    /**
+     * BeiDou D1.
+     */
+    BeidouD1 = 3,
+    /**
+     * BeiDou D2.
+     */
+    BeidouD2 = 4,
+}
+
+/**
+ * One RINEX OBS epoch. Observation values are read through `RinexObs` methods.
+ */
+export class ObsEpoch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Civil epoch in the file time scale.
+     */
+    readonly epoch: ObsEpochTime;
+    /**
+     * RINEX epoch flag. `0` is a normal observation epoch.
+     */
+    readonly flag: number;
+    /**
+     * Number of satellites present at this epoch.
+     */
+    readonly satelliteCount: number;
+    /**
+     * Satellite tokens present at this epoch.
+     */
+    readonly satellites: string[];
+}
+
+/**
+ * Civil epoch from a RINEX observation file, in the file time scale.
+ */
+export class ObsEpochTime {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Calendar day of month, 1..31.
+     */
+    readonly day: number;
+    /**
+     * Hour of day, 0..23.
+     */
+    readonly hour: number;
+    /**
+     * Minute of hour, 0..59.
+     */
+    readonly minute: number;
+    /**
+     * Calendar month, 1..12.
+     */
+    readonly month: number;
+    /**
+     * Fractional seconds of minute.
+     */
+    readonly second: number;
+    /**
+     * Calendar year.
+     */
+    readonly year: number;
+}
+
+/**
+ * Parsed RINEX OBS header.
+ */
+export class ObsHeader {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Observation codes for a constellation, in RINEX header order.
+     */
+    obsCodes(system: GnssSystem): string[];
+    /**
+     * Antenna H/E/N offset `[h, e, n]`, metres, or `undefined`.
+     */
+    readonly antennaDeltaHenM: Float64Array | undefined;
+    /**
+     * Surveyed a-priori ECEF position `[x, y, z]`, metres, or `undefined`.
+     */
+    readonly approxPositionM: Float64Array | undefined;
+    /**
+     * GLONASS slot/frequency-channel pairs, flat `[slot0, chan0, slot1, ...]`.
+     */
+    readonly glonassSlots: Int32Array;
+    /**
+     * Nominal epoch interval, seconds, or `undefined`.
+     */
+    readonly intervalS: number | undefined;
+    /**
+     * Marker or station name, or `undefined`.
+     */
+    readonly markerName: string | undefined;
+    /**
+     * Carrier phase-shift records, in header order.
+     */
+    readonly phaseShifts: ObsPhaseShift[];
+    /**
+     * Constellations with declared observation-code lists.
+     */
+    readonly systems: any[];
+    /**
+     * First observation epoch, or `undefined`.
+     */
+    readonly timeOfFirstObsEpoch: ObsEpochTime | undefined;
+    /**
+     * Time scale of the first observation epoch, or `undefined`.
+     */
+    readonly timeOfFirstObsScale: TimeScale | undefined;
+    /**
+     * RINEX version, for example `3.05`.
+     */
+    readonly version: number;
+}
+
+/**
+ * One `SYS / PHASE SHIFT` record from a RINEX OBS header.
+ */
+export class ObsPhaseShift {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * RINEX carrier observation code, such as `L1C`.
+     */
+    readonly code: string;
+    /**
+     * Phase correction in carrier cycles.
+     */
+    readonly correctionCycles: number;
+    /**
+     * Satellite tokens this correction is restricted to. Empty means all.
+     */
+    readonly satellites: string[];
+    /**
+     * Constellation this correction applies to.
+     */
+    readonly system: GnssSystem;
+}
+
+/**
+ * Optional observation-code allow-list for raw and carrier-phase rows. Build
+ * with `new ObservationFilter()` then chain `.withSystem(system, codes)`.
+ */
+export class ObservationFilter {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * An empty filter that keeps every parsed observation.
+     */
+    constructor();
+    /**
+     * Return a copy with one constellation's code allow-list set.
+     */
+    withSystem(system: GnssSystem, codes: string[]): ObservationFilter;
+}
+
+/**
+ * Observation kind inferred from a RINEX observation code.
+ */
+export enum ObservationKind {
+    /**
+     * Code pseudorange, metres.
+     */
+    Pseudorange = 0,
+    /**
+     * Carrier phase, cycles.
+     */
+    CarrierPhase = 1,
+    /**
+     * Doppler, hertz.
+     */
+    Doppler = 2,
+    /**
+     * Signal strength, dB-Hz.
+     */
+    SignalStrength = 3,
+    /**
+     * Unknown leading RINEX code letter.
+     */
+    Unknown = 4,
+}
+
+/**
+ * Flattened raw observation rows from one RINEX OBS epoch. Numeric arrays are
+ * row-aligned with `satellites`, `codes`, and `kinds`; blank RINEX values, LLI,
+ * and SSI are `NaN`.
+ */
+export class ObservationValueSeries {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * RINEX observation codes, row-aligned with all arrays.
+     */
+    readonly codes: string[];
+    /**
+     * Observation kinds, row-aligned with all arrays.
+     */
+    readonly kinds: any[];
+    /**
+     * Number of flattened rows.
+     */
+    readonly length: number;
+    /**
+     * RINEX LLI values, `NaN` for blanks.
+     */
+    readonly lli: Float64Array;
+    /**
+     * Satellite tokens, row-aligned with all arrays.
+     */
+    readonly satellites: string[];
+    /**
+     * RINEX SSI values, `NaN` for blanks.
+     */
+    readonly ssi: Float64Array;
+    /**
+     * Parsed observation values, as a `Float64Array`.
+     */
+    readonly values: Float64Array;
+}
+
+/**
+ * A canonical, format-agnostic CCSDS Orbit Mean-Elements Message.
+ */
+export class Omm {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OMM. The eight leading arguments are required; `meta` carries the
+     * optional fields (`ccsdsOmmVers`, `creationDate`, ... `bstar`,
+     * `meanMotionDot`, `meanMotionDdot`).
+     */
+    constructor(epoch: OmmEpoch, mean_motion: number, eccentricity: number, inclination_deg: number, ra_of_asc_node_deg: number, arg_of_pericenter_deg: number, mean_anomaly_deg: number, norad_cat_id: number, meta: any);
+    /**
+     * Encode this OMM to CCSDS/CelesTrak JSON text.
+     */
+    toJsonString(): string;
+    /**
+     * Encode this OMM to CCSDS OMM KVN text.
+     */
+    toKvnString(): string;
+    /**
+     * Encode this OMM to CCSDS OMM XML text.
+     */
+    toXmlString(): string;
+    /**
+     * Argument of pericenter, degrees.
+     */
+    readonly argOfPericenterDeg: number;
+    /**
+     * B* drag term.
+     */
+    readonly bstar: number;
+    /**
+     * CCSDS OMM version string.
+     */
+    readonly ccsdsOmmVers: string;
+    /**
+     * Center name.
+     */
+    readonly centerName: string | undefined;
+    /**
+     * Classification type.
+     */
+    readonly classificationType: string;
+    /**
+     * Creation date.
+     */
+    readonly creationDate: string | undefined;
+    /**
+     * Eccentricity.
+     */
+    readonly eccentricity: number;
+    /**
+     * Element set number.
+     */
+    readonly elementSetNo: number;
+    /**
+     * SGP4 ephemeris type.
+     */
+    readonly ephemerisType: number;
+    /**
+     * The epoch.
+     */
+    readonly epoch: OmmEpoch;
+    /**
+     * Inclination, degrees.
+     */
+    readonly inclinationDeg: number;
+    /**
+     * Mean anomaly, degrees.
+     */
+    readonly meanAnomalyDeg: number;
+    /**
+     * Mean-element theory.
+     */
+    readonly meanElementTheory: string | undefined;
+    /**
+     * Mean motion, rev/day.
+     */
+    readonly meanMotion: number;
+    /**
+     * Second derivative of mean motion.
+     */
+    readonly meanMotionDdot: number;
+    /**
+     * First derivative of mean motion.
+     */
+    readonly meanMotionDot: number;
+    /**
+     * NORAD catalog number.
+     */
+    readonly noradCatId: number;
+    /**
+     * Object id.
+     */
+    readonly objectId: string | undefined;
+    /**
+     * Object name.
+     */
+    readonly objectName: string | undefined;
+    /**
+     * Originator.
+     */
+    readonly originator: string | undefined;
+    /**
+     * Right ascension of the ascending node, degrees.
+     */
+    readonly raOfAscNodeDeg: number;
+    /**
+     * Reference frame.
+     */
+    readonly refFrame: string | undefined;
+    /**
+     * Revolution number at epoch.
+     */
+    readonly revAtEpoch: bigint;
+    /**
+     * Time system.
+     */
+    readonly timeSystem: string | undefined;
+}
+
+/**
+ * UTC calendar epoch carried by an OMM `EPOCH` field.
+ */
+export class OmmEpoch {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an OMM epoch from UTC calendar fields. Throws a `RangeError` on an
+     * out-of-range field.
+     */
+    constructor(year: number, month: number, day: number, hour: number, minute: number, second: number, microsecond: number);
+    /**
+     * Calendar day.
+     */
+    readonly day: number;
+    /**
+     * Hour of day.
+     */
+    readonly hour: number;
+    /**
+     * ISO-8601 epoch text with microsecond precision.
+     */
+    readonly iso8601: string;
+    /**
+     * Microsecond of second.
+     */
+    readonly microsecond: number;
+    /**
+     * Minute of hour.
+     */
+    readonly minute: number;
+    /**
+     * Calendar month.
+     */
+    readonly month: number;
+    /**
+     * Second of minute.
+     */
+    readonly second: number;
+    /**
+     * Calendar year.
+     */
+    readonly year: number;
+}
+
+/**
+ * Static integer-fixed PPP solution.
+ */
+export class PppFixedSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly codeRmsM: number;
+    readonly converged: boolean;
+    /**
+     * Fixed ambiguities, integer cycles, as an id-keyed object.
+     */
+    readonly fixedAmbiguitiesCycles: any;
+    /**
+     * Fixed ambiguities, metres, as an id-keyed object.
+     */
+    readonly fixedAmbiguitiesM: any;
+    /**
+     * The float solution that seeded the integer search.
+     */
+    readonly floatSolution: PppFloatSolution;
+    readonly integerCandidates: number;
+    readonly integerRatio: number;
+    /**
+     * Integer ambiguity-fix status: `"Fixed"` or `"NotFixed"`.
+     */
+    readonly integerStatus: string;
+    readonly iterations: number;
+    readonly phaseRmsM: number;
+    /**
+     * ECEF position as a `Float64Array` `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Satellite tokens used in the accepted solution.
+     */
+    readonly usedSats: string[];
+    readonly weightedRmsM: number;
+    /**
+     * Estimated zenith tropospheric delay residual, metres, or `undefined`.
+     */
+    readonly ztdResidualM: number | undefined;
+}
+
+/**
+ * Static float PPP solution.
+ */
+export class PppFloatSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Float ambiguities, metres, as an id-keyed object.
+     */
+    readonly ambiguitiesM: any;
+    readonly codeRmsM: number;
+    readonly converged: boolean;
+    readonly iterations: number;
+    readonly phaseRmsM: number;
+    /**
+     * ECEF position as a `Float64Array` `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Satellite tokens used in the accepted solution.
+     */
+    readonly usedSats: string[];
+    readonly weightedRmsM: number;
+    /**
+     * Estimated zenith tropospheric delay residual, metres, or `undefined`.
+     */
+    readonly ztdResidualM: number | undefined;
+}
+
+/**
+ * Reason a satellite was dropped from paired pseudorange combination.
+ */
+export enum PseudorangeDropReason {
+    /**
+     * Present in band 2 only.
+     */
+    MissingBand1 = 0,
+    /**
+     * Present in band 1 only.
+     */
+    MissingBand2 = 1,
+    /**
+     * Repeated within at least one input band.
+     */
+    DuplicateObservation = 2,
+    /**
+     * Unsupported constellation or override band.
+     */
+    UnknownSystem = 3,
+}
+
+/**
+ * Flattened pseudorange rows from one RINEX OBS epoch. `satellites` is
+ * row-aligned with `rangesM`; ranges are metres.
+ */
+export class PseudorangeSeries {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of rows.
+     */
+    readonly length: number;
+    /**
+     * Pseudorange values, metres, as a `Float64Array`.
+     */
+    readonly rangesM: Float64Array;
+    /**
+     * Satellite tokens, row-aligned with `rangesM`.
+     */
+    readonly satellites: string[];
+}
+
+/**
+ * RAIM weighting mode: either unit weights or per-satellite inverse-variance
+ * weights (missing satellites default to unit weight).
+ */
+export class RaimWeights {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Per-satellite inverse-variance weights. `weights` must be positive and
+     * finite and the same length as `satelliteIds`. Throws a `TypeError` on a
+     * length mismatch and a `RangeError` on a non-positive weight.
+     */
+    static bySatellite(satellite_ids: string[], weights: Float64Array): RaimWeights;
+    /**
+     * Unit weights, equivalent to sigma = 1 m for every satellite.
+     */
+    static unit(): RaimWeights;
+    /**
+     * True when all satellites use unit weight.
+     */
+    readonly isUnit: boolean;
+    /**
+     * Satellite tokens for per-satellite weights, sorted by token.
+     */
+    readonly satelliteIds: string[];
+    /**
+     * Inverse-variance weights as a `Float64Array`, sorted by satellite token.
+     */
+    readonly weights: Float64Array;
+}
+
+/**
+ * A parsed RINEX clock product with satellite clock-bias interpolation.
+ */
+export class RinexClock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Interpolate one satellite clock bias at a GPS-time civil epoch.
+     * Returns `undefined` if the satellite or epoch coverage is absent.
+     */
+    clockS(satellite_id: string, epoch: ClockEpoch): number | undefined;
+    /**
+     * Interpolate one satellite clock bias at GPS seconds. Throws a
+     * `RangeError` if `gpsSeconds` is non-finite.
+     */
+    clockSAtGpsSeconds(satellite_id: string, gps_seconds: number): number | undefined;
+    /**
+     * One satellite's clock series, or `undefined` if the satellite is absent.
+     */
+    seriesFor(satellite_id: string): ClockSeries | undefined;
+    /**
+     * Total number of parsed satellite clock samples.
+     */
+    readonly sampleCount: number;
+    /**
+     * Number of satellites with clock samples.
+     */
+    readonly satelliteCount: number;
+    /**
+     * Satellite tokens with at least one parsed `AS` clock sample.
+     */
+    readonly satellites: string[];
+    /**
+     * Per-satellite clock-bias series in satellite sort order.
+     */
+    readonly series: ClockSeries[];
+}
+
+/**
+ * A parsed RINEX 3/4 observation file.
+ */
+export class RinexObs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Flatten carrier-phase values for one epoch.
+     */
+    carrierPhaseRows(epoch_index: number, filter?: ObservationFilter | null): CarrierPhaseSeries;
+    /**
+     * One epoch by zero-based index. Throws a `RangeError` if out of range.
+     */
+    epoch(epoch_index: number): ObsEpoch;
+    /**
+     * Observation codes for a constellation, in header order.
+     */
+    obsCodes(system: GnssSystem): string[];
+    /**
+     * Flatten raw observation values for one epoch.
+     */
+    observationValues(epoch_index: number, filter?: ObservationFilter | null): ObservationValueSeries;
+    /**
+     * Extract single-frequency pseudoranges for one epoch.
+     */
+    pseudoranges(epoch_index: number, policy?: SignalPolicy | null): PseudorangeSeries;
+    /**
+     * Number of parsed epoch records.
+     */
+    readonly epochCount: number;
+    /**
+     * Epoch records in file order.
+     */
+    readonly epochs: ObsEpoch[];
+    /**
+     * Parsed RINEX OBS header.
+     */
+    readonly header: ObsHeader;
+}
+
+/**
+ * Validated fixed RTK baseline solution.
+ */
+export class RtkFixedSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly converged: boolean;
+    /**
+     * Fixed (integer-resolved) baseline as a `Float64Array` `[dx, dy, dz]`, metres.
+     */
+    readonly fixedBaselineM: Float64Array;
+    /**
+     * The underlying float baseline as a `Float64Array` `[dx, dy, dz]`, metres.
+     */
+    readonly floatBaselineM: Float64Array;
+    readonly integerCandidates: number;
+    /**
+     * Integer ambiguity ratio, or `undefined` when no ratio was computed.
+     */
+    readonly integerRatio: number | undefined;
+    /**
+     * Integer ambiguity-fix status: `"Fixed"` or `"NotFixed"`.
+     */
+    readonly integerStatus: string;
+}
+
+/**
+ * Static float RTK baseline solution.
+ */
+export class RtkFloatSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Float single-difference ambiguities, metres, as an id-keyed object.
+     */
+    readonly ambiguitiesM: any;
+    /**
+     * Baseline (rover minus base) as a `Float64Array` `[dx, dy, dz]`, metres.
+     */
+    readonly baselineM: Float64Array;
+    readonly codeRmsM: number;
+    readonly converged: boolean;
+    readonly iterations: number;
+    readonly nObservations: number;
+    readonly phaseRmsM: number;
+    readonly weightedRmsM: number;
+}
+
+/**
+ * A satellite pass over a ground station: acquisition of signal, loss of
+ * signal, culmination time (all unix microseconds UTC), and the elevation at
+ * culmination.
+ */
+export class SatellitePass {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Acquisition of signal (rise above the mask), unix microseconds UTC.
+     */
+    readonly aosUnixUs: bigint;
+    /**
+     * Culmination (maximum elevation) time, unix microseconds UTC.
+     */
+    readonly culminationUnixUs: bigint;
+    /**
+     * Pass duration (LOS minus AOS), seconds.
+     */
+    readonly durationS: number;
+    /**
+     * Loss of signal (set below the mask), unix microseconds UTC.
+     */
+    readonly losUnixUs: bigint;
+    /**
+     * Elevation at culmination, degrees.
+     */
+    readonly maxElevationDeg: number;
+}
+
+/**
+ * Satellite-keyed measurement sigmas (metres) or inverse-variance weights.
+ */
+export class SatelliteVector {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Satellite tokens, sorted, row-aligned with `values`.
+     */
+    readonly satelliteIds: string[];
+    /**
+     * Per-satellite values as a `Float64Array`.
+     */
+    readonly values: Float64Array;
+}
+
+/**
+ * Per-constellation single-frequency pseudorange code-selection policy. Build
+ * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
+ * the static `defaultFor(version)`.
+ */
+export class SignalPolicy {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The core default pseudorange policy for a RINEX version.
+     */
+    static defaultFor(version: number): SignalPolicy;
+    /**
+     * An empty policy with no constellation preferences.
+     */
+    constructor();
+    /**
+     * Return a copy with one constellation's preference list set.
+     */
+    withSystem(system: GnssSystem, codes: string[]): SignalPolicy;
+}
+
+/**
+ * Reason a carrier-phase arc split was flagged.
+ */
+export enum SlipReason {
+    /**
+     * Loss-of-lock indicator bit 0 set on either band.
+     */
+    Lli = 0,
+    /**
+     * Gap to the previous usable sample exceeded the threshold.
+     */
+    DataGap = 1,
+    /**
+     * Geometry-free phase step exceeded the threshold.
+     */
+    GeometryFree = 2,
+    /**
+     * Melbourne-Wubbena step exceeded the threshold.
+     */
+    MelbourneWubbena = 3,
+}
+
+/**
+ * Cycle-slip classification for one input epoch.
+ */
+export class SlipResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Current geometry-free phase, metres, or `undefined`.
+     */
+    readonly gfM: number | undefined;
+    /**
+     * Current Melbourne-Wubbena combination, metres, or `undefined`.
+     */
+    readonly mwM: number | undefined;
+    /**
+     * Slip reasons in deterministic API order.
+     */
+    readonly reasons: any[];
+    /**
+     * Whether the epoch was skipped because a frequency was unavailable.
+     */
+    readonly skipped: boolean;
+    /**
+     * Whether any slip reason was flagged.
+     */
+    readonly slip: boolean;
+}
+
+/**
+ * Hatch-smoothed single-frequency code output for one epoch.
+ */
+export class SmoothCodeResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Smoothed code pseudorange, metres, or `undefined`.
+     */
+    readonly pSmoothM: number | undefined;
+    /**
+     * True when a prior running window was reset by a slip.
+     */
+    readonly reset: boolean;
+    /**
+     * Hatch window length used at this epoch.
+     */
+    readonly window: number;
+}
+
+/**
+ * A receiver solution paired with the provenance of the ephemeris that produced
+ * it. Returned by [`solveWithFallback`].
+ */
+export class SourcedSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The solved receiver position / clock as an [`SppSolution`].
+     */
+    readonly solution: SppSolution;
+    /**
+     * Which ephemeris source produced the fix, with its staleness / rejection
+     * provenance, as a plain object (see [`FixSourceJs`]).
+     */
+    readonly source: any;
+}
+
+/**
+ * A parsed SP3-c or SP3-d precise-ephemeris product.
+ *
+ * Create with [`load_sp3`]. Query interpolated states with
+ * [`Sp3.interpolate`], the exact parsed records with [`Sp3.state`], the node
+ * epoch axis with [`Sp3.epochsJ2000Seconds`], run positioning with
+ * [`Sp3.solveSpp`], and serialize back with [`Sp3.toSp3String`].
+ */
+export class Sp3 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Compute DGNSS pseudorange corrections from a surveyed base station.
+     *
+     * `request` is `{ basePositionM, baseObservations, tRxJ2000S }`; returns a
+     * `{ satelliteId, correctionM }[]` array sorted by satellite token.
+     */
+    dgnssCorrections(request: any): any;
+    /**
+     * Solve a DGNSS rover position: compute base corrections, apply them to the
+     * rover, and run the corrected SPP. `request` carries the base + rover
+     * observations and the receive-time scalars; see the `DgnssSolveRequest`
+     * TypeScript type. Returns the corrected solution and the base baseline.
+     */
+    dgnssSolve(request: any): DgnssSolution;
+    /**
+     * The product's parsed epochs as seconds since J2000 (the product's own
+     * time scale), ascending. This is the exact axis [`Sp3.interpolate`]
+     * consumes.
+     */
+    epochsJ2000Seconds(): Float64Array;
+    /**
+     * Run fault detection and exclusion (FDE) against this ephemeris.
+     *
+     * `request` is the SPP solve request plus the RAIM/exclusion options (see
+     * the `FdeRequest` TypeScript type). The core loop solves, runs RAIM, and
+     * excludes the worst satellite until the set passes or the exclusion budget
+     * is exhausted. Returns the surviving solution and the excluded satellites;
+     * throws an `Error` if the fault is unresolved.
+     */
+    fde(request: any): FdeSolution;
+    /**
+     * Interpolate `satellite`'s position and clock at each query epoch.
+     *
+     * `j2000Seconds` is a `Float64Array` of query times in seconds since J2000,
+     * in the product's own time scale. Throws a `TypeError` if the satellite is
+     * absent or the query array is empty, and an `Error` if a query lies in a
+     * coverage gap (the engine refuses to extrapolate).
+     */
+    interpolate(satellite: string, j2000_seconds: Float64Array): Sp3Interpolation;
+    /**
+     * Run single-point positioning against this ephemeris.
+     *
+     * `request` is a plain object; see the `SppRequest` TypeScript type. Throws
+     * a `TypeError` for malformed input and an `Error` if the solve fails.
+     */
+    solveSpp(request: any): SppSolution;
+    /**
+     * The exact parsed state of `satellite` at record `epochIndex` (no
+     * interpolation). Throws a `RangeError` past the last epoch and a
+     * `TypeError` if the satellite has no record there.
+     */
+    state(satellite: string, epoch_index: number): Sp3State;
+    /**
+     * Serialize to standard SP3 text (the version named by the header, `c` or
+     * `d`). Deterministic: the same product always produces byte-identical text.
+     */
+    toSp3String(): string;
+    /**
+     * Number of epochs in the product.
+     */
+    readonly epochCount: number;
+    /**
+     * Satellite tokens present in the product (e.g. `"G01"`), ascending.
+     */
+    readonly satellites: string[];
+}
+
+/**
+ * A batch of interpolated SP3 states.
+ */
+export class Sp3Interpolation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Interpolated clock offsets, seconds, as a `Float64Array` (NaN where the
+     * satellite has no clock estimate at that epoch).
+     */
+    readonly clockS: Float64Array;
+    /**
+     * Number of query epochs in the batch.
+     */
+    readonly epochCount: number;
+    /**
+     * Interpolated ECEF positions, metres, as a flat row-major `Float64Array`
+     * of length `3 * epochCount` (`[x0, y0, z0, x1, y1, z1, ...]`).
+     */
+    readonly positionM: Float64Array;
+}
+
+/**
+ * One SP3 merge audit flag for an epoch and satellite.
+ */
+export class Sp3MergeFlag {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Flagged epoch as seconds since J2000 in the product time scale.
+     */
+    readonly epochJ2000Seconds: number;
+    /**
+     * Satellite token, e.g. `"G01"`.
+     */
+    readonly satellite: string;
+    /**
+     * Source indices (into the input array) this flag refers to.
+     */
+    readonly sources: Uint32Array;
+}
+
+/**
+ * Audit report returned with a merged SP3 product.
+ */
+export class Sp3MergeReport {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly positionOutlierCount: number;
+    /**
+     * Cells where an accepted consensus rejected source outliers.
+     */
+    readonly positionOutliers: Sp3MergeFlag[];
+    /**
+     * Cells omitted because sources disagreed beyond tolerance.
+     */
+    readonly quarantined: Sp3MergeFlag[];
+    readonly quarantinedCount: number;
+    /**
+     * Cells carried from one source because no cross-check was possible.
+     */
+    readonly singleSource: Sp3MergeFlag[];
+    readonly singleSourceCount: number;
+}
+
+/**
+ * The result of an SP3 merge: the merged product plus the audit report.
+ */
+export class Sp3MergeResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The merge audit report.
+     */
+    readonly report: Sp3MergeReport;
+    /**
+     * The merged precise orbit and clock product.
+     */
+    readonly sp3: Sp3;
+}
+
+/**
+ * A staleness-selected SP3 product plus its [`StalenessMetadata`].
+ */
+export class Sp3Selection {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Interpolate `satellite` at `queryJ2000S` on the selected product, returning
+     * a plain object `{ positionM: [x, y, z], clockS: number | null }`. Delegates
+     * to the reference interpolation, so an exact selection matches the caller's
+     * product bit-for-bit. Throws a `TypeError` for an unknown satellite and an
+     * `Error` for a query in a coverage gap.
+     */
+    positionAtJ2000Seconds(satellite: string, query_j2000_s: number): any;
+    /**
+     * The staleness metadata as a plain object (see [`StalenessMetadataJs`]).
+     */
+    readonly metadata: any;
+    /**
+     * The selected SP3 product as a standalone [`Sp3`] handle, exposing the full
+     * SP3 query / solve surface.
+     */
+    readonly sp3: Sp3;
+}
+
+/**
+ * The exact parsed state of one satellite at one SP3 epoch.
+ */
+export class Sp3State {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Clock discontinuity (`E`) flagged at this epoch.
+     */
+    readonly clockEvent: boolean;
+    /**
+     * The clock is predicted, not fitted.
+     */
+    readonly clockPredicted: boolean;
+    /**
+     * Clock offset in seconds, or `undefined` for the bad-clock sentinel.
+     */
+    readonly clockS: number | undefined;
+    /**
+     * The satellite was being maneuvered at this epoch.
+     */
+    readonly maneuver: boolean;
+    /**
+     * The orbit is predicted, not fitted.
+     */
+    readonly orbitPredicted: boolean;
+    /**
+     * ECEF position as a `Float64Array` `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * ECEF velocity as a `Float64Array` `[vx, vy, vz]`, metres per second, or
+     * `undefined` for a position-only product.
+     */
+    readonly velocityMS: Float64Array | undefined;
+}
+
+/**
+ * A parsed in-memory JPL/NAIF SPK kernel.
+ *
+ * Construct from the raw `.bsp` bytes (a `Uint8Array`), then query states with
+ * [`Spk.state`] or inspect the segment table with [`Spk.segments`].
+ *
+ * ```js
+ * import init, { Spk } from "@neilberkman/sidereon";
+ * await init();
+ * const spk = new Spk(new Uint8Array(bspBytes));
+ * const state = spk.state(20000433, 10, 757339200.0);
+ * state.positionKm; // Float64Array [x, y, z] km
+ * state.velocityKmS; // Float64Array [vx, vy, vz] km/s (or undefined)
+ * ```
+ */
+export class Spk {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Parse an SPK/DAF kernel from its raw bytes (the full, decompressed
+     * `.bsp` file). Throws an `Error` if the bytes are not a supported SPK
+     * kernel.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * Query the state of NAIF `target` relative to NAIF `center` at `et`
+     * (ET/TDB seconds past J2000). Resolves the segment chain connecting the
+     * two bodies and evaluates SPK Types 2, 3, and 21.
+     *
+     * Throws a `RangeError` if `et` is not finite, and an `Error` if the bodies
+     * are absent, unconnected, out of coverage, or in an unsupported segment.
+     */
+    state(target: number, center: number, et: number): SpkState;
+    /**
+     * The DAF internal name from the file record.
+     */
+    readonly internalName: string;
+    /**
+     * Number of segments in the kernel.
+     */
+    readonly segmentCount: number;
+    /**
+     * Segment descriptors in DAF summary order.
+     */
+    readonly segments: SpkSegment[];
+}
+
+/**
+ * A descriptor for one SPK segment as recorded in the DAF summary, in summary
+ * order. Read via [`Spk.segments`].
+ */
+export class SpkSegment {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * NAIF center body id.
+     */
+    readonly center: number;
+    /**
+     * SPK segment data type (2, 3, or 21 for the supported evaluators).
+     */
+    readonly dataType: number;
+    /**
+     * NAIF reference-frame id.
+     */
+    readonly frame: number;
+    /**
+     * Segment comment/name from the DAF summary record.
+     */
+    readonly name: string;
+    /**
+     * Coverage start, ET/TDB seconds past J2000.
+     */
+    readonly startEt: number;
+    /**
+     * Coverage stop, ET/TDB seconds past J2000.
+     */
+    readonly stopEt: number;
+    /**
+     * NAIF target body id.
+     */
+    readonly target: number;
+}
+
+/**
+ * The state of a target relative to a center, resolved from an SPK query.
+ * Returned by [`Spk.state`].
+ */
+export class SpkState {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * NAIF center body id for the returned relative state.
+     */
+    readonly center: number;
+    /**
+     * NAIF reference-frame id shared by all segments in the resolved path.
+     */
+    readonly frame: number;
+    /**
+     * Position of the target relative to the center as a `Float64Array`
+     * `[x, y, z]`, kilometres.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * NAIF target body id for the returned relative state.
+     */
+    readonly target: number;
+    /**
+     * Velocity of the target relative to the center as a `Float64Array`
+     * `[vx, vy, vz]`, kilometres per second, or `undefined` when the resolved
+     * path includes a Type-2 segment (which stores position only).
+     */
+    readonly velocityKmS: Float64Array | undefined;
+}
+
+/**
+ * The result of an SPP solve.
+ */
+export class SppSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * `[latRad, lonRad, heightM]` as a `Float64Array` if the solve was asked
+     * for geodetic output, otherwise `undefined`.
+     */
+    readonly geodetic: Float64Array | undefined;
+    /**
+     * ECEF position as a `Float64Array` `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Post-fit residuals, metres, index-aligned to `usedSats`.
+     */
+    readonly residualsM: Float64Array;
+    /**
+     * Receiver clock bias, seconds.
+     */
+    readonly rxClockS: number;
+    /**
+     * Satellite tokens used in the accepted solution, ascending.
+     */
+    readonly usedSats: string[];
+    /**
+     * ECEF X, metres.
+     */
+    readonly xM: number;
+    /**
+     * ECEF Y, metres.
+     */
+    readonly yM: number;
+    /**
+     * ECEF Z, metres.
+     */
+    readonly zM: number;
+}
+
+/**
+ * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
+ * `moon` `Float64Array`s of length `3 * epochCount`, in **metres**.
+ *
+ * The frame (geocentric ECI of date vs Earth-fixed ITRS/ECEF) is fixed by which
+ * function produced this object: [`sunMoonEci`] or [`sunMoonEcef`].
+ */
+export class SunMoon {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of epochs in the batch.
+     */
+    readonly epochCount: number;
+    /**
+     * The frame these positions are in: `"eci"` or `"ecef"`.
+     */
+    readonly frame: string;
+    /**
+     * Moon positions, metres, flat row-major `(n, 3)`.
+     */
+    readonly moon: Float64Array;
+    /**
+     * Sun positions, metres, flat row-major `(n, 3)`.
+     */
+    readonly sun: Float64Array;
+}
+
+/**
+ * A named time scale. The JS value matches the variant order below.
+ */
+export enum TimeScale {
+    /**
+     * Coordinated Universal Time.
+     */
+    Utc = 0,
+    /**
+     * International Atomic Time.
+     */
+    Tai = 1,
+    /**
+     * Terrestrial Time.
+     */
+    Tt = 2,
+    /**
+     * Barycentric Dynamical Time.
+     */
+    Tdb = 3,
+    /**
+     * GPS time.
+     */
+    Gpst = 4,
+    /**
+     * Galileo System Time.
+     */
+    Gst = 5,
+    /**
+     * BeiDou Time.
+     */
+    Bdt = 6,
+}
+
+/**
+ * A parsed two-line element set with an initialized SGP4 satellite.
+ */
+export class Tle {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Find passes over `station` within `[startUnixUs, endUnixUs)` by dense
+     * elevation sampling. `elevationMaskDeg` defaults to 0, `stepSeconds` to 30,
+     * `timeToleranceS` to 1e-3. Throws a `RangeError` on a non-positive step or
+     * an end at or before the start.
+     */
+    findPasses(station: GroundStation, start_unix_us: bigint, end_unix_us: bigint, elevation_mask_deg?: number | null, step_seconds?: number | null, time_tolerance_s?: number | null): SatellitePass[];
+    /**
+     * Topocentric azimuth/elevation/range from `station` over a
+     * `BigInt64Array` of unix-microsecond epochs. Throws an `Error` on failure.
+     */
+    lookAngles(station: GroundStation, epochs_unix_us: BigInt64Array): LookAngles;
+    /**
+     * Parse two TLE lines and initialize SGP4. `opsMode` is `"improved"`
+     * (default) or `"afspc"`. Throws an `Error` if the lines fail to parse or
+     * SGP4 fails to initialize.
+     */
+    constructor(line1: string, line2: string, ops_mode_label?: string | null);
+    /**
+     * Propagate over a `BigInt64Array` of unix-microsecond epochs. Returns TEME
+     * position (km) and velocity (km/s). Throws an `Error` on SGP4 failure.
+     */
+    propagate(epochs_unix_us: BigInt64Array): TlePropagation;
+    /**
+     * Re-encode the parsed elements as the two 69-character TLE lines (with
+     * checksums), as a `[line1, line2]` string array. For a well-formed input
+     * the round-trip is character-exact.
+     */
+    toLines(): string[];
+    /**
+     * Topocentric visibility arrays and a dense pass list over an epoch grid.
+     *
+     * `epochsUnixUs` must be a strictly increasing `BigInt64Array` with at least
+     * two samples. The az/el geometry is the same path as [`lookAngles`]; the
+     * pass list is the dense finder over `[first, last]`.
+     */
+    visibilitySeries(station: GroundStation, epochs_unix_us: BigInt64Array, elevation_mask_deg?: number | null, step_seconds?: number | null, time_tolerance_s?: number | null): VisibilitySeries;
+    /**
+     * Argument of perigee, degrees.
+     */
+    readonly argPerigeeDeg: number;
+    /**
+     * B* drag term (TLE dimensionless convention).
+     */
+    readonly bstar: number;
+    /**
+     * NORAD catalog number (as recorded in the TLE).
+     */
+    readonly catalogNumber: string;
+    /**
+     * Advisory checksum discrepancies found while parsing. Empty when both
+     * lines' checksums are valid.
+     */
+    readonly checksumWarnings: ChecksumWarning[];
+    /**
+     * Classification character (`U`/`C`/`S`).
+     */
+    readonly classification: string;
+    /**
+     * Orbital eccentricity (dimensionless).
+     */
+    readonly eccentricity: number;
+    /**
+     * Fractional day-of-year of the epoch.
+     */
+    readonly epochDayOfYear: number;
+    /**
+     * Four-digit epoch year.
+     */
+    readonly epochYear: number;
+    /**
+     * Inclination, degrees.
+     */
+    readonly inclinationDeg: number;
+    /**
+     * International designator (COSPAR ID).
+     */
+    readonly internationalDesignator: string;
+    /**
+     * Mean anomaly at epoch, degrees.
+     */
+    readonly meanAnomalyDeg: number;
+    /**
+     * First derivative of mean motion (rev/day^2).
+     */
+    readonly meanMotionDot: number;
+    /**
+     * Second derivative of mean motion (rev/day^3).
+     */
+    readonly meanMotionDoubleDot: number;
+    /**
+     * Mean motion, revolutions per day.
+     */
+    readonly meanMotionRevPerDay: number;
+    /**
+     * Right ascension of the ascending node, degrees.
+     */
+    readonly raanDeg: number;
+    /**
+     * Revolution number at epoch.
+     */
+    readonly revNumber: number;
+}
+
+/**
+ * TEME states from a batched SGP4 propagation. Each array is flat row-major,
+ * length `3 * epochCount`.
+ */
+export class TlePropagation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of epochs propagated.
+     */
+    readonly epochCount: number;
+    /**
+     * TEME positions, km, flat `[x0, y0, z0, x1, ...]`.
+     */
+    readonly positionKm: Float64Array;
+    /**
+     * TEME velocities, km/s, flat `[vx0, vy0, vz0, ...]`.
+     */
+    readonly velocityKmS: Float64Array;
+}
+
+/**
+ * Provenance and coverage of the embedded UT1-UTC / delta-T (EOP) table.
+ */
+export class Ut1Coverage {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Number of entries in the table.
+     */
+    readonly entries: number;
+    /**
+     * TT Julian date of the first table entry (coverage lower bound).
+     */
+    readonly firstJdTt: number;
+    /**
+     * Modified Julian date of the first table entry.
+     */
+    readonly firstMjd: number;
+    /**
+     * TT Julian date of the last table entry (coverage upper bound).
+     */
+    readonly lastJdTt: number;
+    /**
+     * Modified Julian date of the last table entry.
+     */
+    readonly lastMjd: number;
+    /**
+     * Human-readable provenance string for the table.
+     */
+    readonly source: string;
+}
+
+/**
+ * Receiver velocity solve result.
+ */
+export class VelocitySolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Receiver clock drift, seconds per second.
+     */
+    readonly clockDriftSS: number;
+    /**
+     * Post-fit range-rate residuals, metres per second.
+     */
+    readonly residualsMS: Float64Array;
+    /**
+     * Receiver speed, metres per second.
+     */
+    readonly speedMS: number;
+    /**
+     * Satellite tokens contributing rows, in residual order.
+     */
+    readonly usedSats: string[];
+    /**
+     * Receiver ECEF velocity `[vx, vy, vz]`, metres per second.
+     */
+    readonly velocityMS: Float64Array;
+}
+
+/**
+ * Per-epoch topocentric visibility plus the dense pass list over the grid
+ * window.
+ */
+export class VisibilitySeries {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Azimuth, degrees clockwise from north.
+     */
+    readonly azimuthDeg: Float64Array;
+    /**
+     * Elevation, degrees above the horizon.
+     */
+    readonly elevationDeg: Float64Array;
+    /**
+     * Number of epochs evaluated.
+     */
+    readonly epochCount: number;
+    /**
+     * Epoch grid, UTC unix microseconds, as a `BigInt64Array`.
+     */
+    readonly epochUnixUs: BigInt64Array;
+    /**
+     * Number of passes found over the epoch-grid window.
+     */
+    readonly passCount: number;
+    /**
+     * Dense pass-finder results over the epoch-grid window.
+     */
+    readonly passes: SatellitePass[];
+    /**
+     * Slant range, kilometres.
+     */
+    readonly rangeKm: Float64Array;
+    /**
+     * Visibility mask as a `Uint8Array` (1 where `elevationDeg >=
+     * elevationMaskDeg`, else 0).
+     */
+    readonly visible: Uint8Array;
+}
+
+/**
+ * WGS84 receiver geodetic coordinates (radians, metres) for DOP.
+ */
+export class Wgs84Geodetic {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build a WGS84 geodetic coordinate. `heightM` defaults to 0. Throws a
+     * `RangeError` on a non-finite field or latitude outside `[-pi/2, pi/2]`.
+     */
+    constructor(lat_rad: number, lon_rad: number, height_m?: number | null);
+    /**
+     * Ellipsoidal height above WGS84, metres.
+     */
+    readonly heightM: number;
+    /**
+     * Geodetic latitude, radians.
+     */
+    readonly latRad: number;
+    /**
+     * Geodetic longitude, radians east.
+     */
+    readonly lonRad: number;
+}
+
+/**
+ * Zenith hydrostatic and wet tropospheric delays, positive metres.
+ */
+export class ZenithDelay {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Zenith hydrostatic (dry) delay, positive metres.
+     */
+    readonly dryM: number;
+    /**
+     * Zenith wet delay, positive metres.
+     */
+    readonly wetM: number;
+}
+
+/**
+ * Acquire a GPS C/A PRN by direct code-phase and Doppler search. `samples` is
+ * interleaved `[i0, q0, i1, q1, ...]`.
+ */
+export function acquire(samples: Float64Array, prn: bigint, options: any): AcquisitionResult;
+
+/**
+ * One wrapping GPS C/A chip at a zero-based index.
+ */
+export function caChip(prn: bigint, index: bigint): number;
+
+/**
+ * GPS C/A code chips for a PRN, an `Int8Array` of length 1023, chips `+1`/`-1`.
+ */
+export function caCode(prn: bigint): Int8Array;
+
+/**
+ * Canonical lower-case carrier-band token, e.g. `"l1"`.
+ */
+export function carrierBandName(band: CarrierBand): string;
+
+/**
+ * Carrier frequency in hertz for a constellation and canonical carrier band.
+ */
+export function carrierFrequencyHz(system: GnssSystem, band: CarrierBand): number | undefined;
+
+/**
+ * Returns `true` when a diff has any findings.
+ */
+export function changed(diff: any): boolean;
+
+/**
+ * Carrier-to-noise-density ratio, dB-Hz. `otherLossesDb` defaults to 0.
+ */
+export function cn0(eirp_dbw: number, fspl_db: number, receiver_gt_dbk: number, other_losses_db?: number | null): number;
+
+/**
+ * Coherent integration loss from residual frequency error.
+ */
+export function coherentLoss(freq_error_hz: number, integration_time_s: number): number;
+
+/**
+ * Coherent integration loss in decibels.
+ */
+export function coherentLossDb(freq_error_hz: number, integration_time_s: number): number;
+
+/**
+ * Compute collision probability from two conjunction states and a hard-body
+ * radius. `method` is one of `"foster_equal_area"` (default),
+ * `"foster_numerical"`, `"alfano_2005"`.
+ */
+export function collisionProbability(object1: ConjunctionState, object2: ConjunctionState, hard_body_radius_km: number, method?: string | null): CollisionProbability;
+
+/**
+ * Coherently correlate interleaved IQ samples against a GPS C/A PRN replica.
+ * `iq` is `[i0, q0, i1, q1, ...]`.
+ */
+export function correlate(iq: Float64Array, prn: bigint, options: any): CorrelationResult;
+
+/**
+ * Whether a 3x3 covariance (flat row-major length 9) is symmetric positive
+ * semidefinite within the engine tolerance.
+ */
+export function covarianceIsPositiveSemidefinite(covariance_km2: Float64Array): boolean;
+
+/**
+ * Whether a 3x3 covariance (flat row-major length 9) is symmetric within the
+ * engine tolerance.
+ */
+export function covarianceIsSymmetric(covariance_km2: Float64Array): boolean;
+
+/**
+ * Decode Compact RINEX (Hatanaka) bytes into plain RINEX OBS text. Throws a
+ * `TypeError` on non-UTF-8 input and an `Error` on a decode failure.
+ */
+export function decodeCrinex(bytes: Uint8Array): string;
+
+/**
+ * Decode Compact RINEX bytes into plain RINEX OBS lines (each without its
+ * trailing newline). Throws a `TypeError` on non-UTF-8 input and an `Error` on
+ * a decode failure.
+ */
+export function decodeCrinexLines(bytes: Uint8Array): string[];
+
+/**
+ * Standard dual-frequency ionosphere-free carrier pair for a constellation.
+ */
+export function defaultPair(system: GnssSystem): CarrierPair | undefined;
+
+/**
+ * Detect cycle slips on a time-ordered single-satellite carrier-phase arc.
+ * `arc` is an array of `{ phi1Cycles?, phi2Cycles?, p1M?, p2M?, lli1?, lli2?,
+ * f1Hz?, f2Hz?, gapTimeS? }`.
+ */
+export function detectCycleSlips(arc: any, options: any): SlipResult[];
+
+/**
+ * Apply base pseudorange corrections to rover observations by satellite token.
+ *
+ * `roverObservations` is `{ satelliteId, pseudorangeM }[]`; `corrections` is the
+ * `{ satelliteId, correctionM }[]` array from [`Sp3.dgnssCorrections`]. Output
+ * order follows the rover order; rover satellites with no correction are
+ * reported in `dropped`.
+ */
+export function dgnssApply(rover_observations: any, corrections: any): AppliedCorrections;
+
+/**
+ * Compare two catalog snapshots by `(system, prn)` identity.
+ *
+ * `previous` and `current` are each a `Record[]`. Returns a `Diff` of added,
+ * removed, and per-field changes on held PRNs.
+ */
+export function diff(previous: any, current: any): any;
+
+/**
+ * Parabolic-dish antenna gain, dBi.
+ */
+export function dishGain(diameter_m: number, frequency_hz: number, efficiency: number): number;
+
+/**
+ * Convert a Doppler shift in hertz to pseudorange rate in metres per second.
+ */
+export function dopplerToRangeRate(doppler_hz: number, carrier_hz: number): number;
+
+/**
+ * Angular radius in degrees of Earth as seen from each satellite position.
+ */
+export function earthAngularRadius(satellite_position_km: Float64Array): Float64Array;
+
+/**
+ * Convert a batch of ITRS (ECEF) positions to geodetic coordinates.
+ *
+ * `positionKm` is a flat row-major `(n, 3)` `Float64Array` in kilometres.
+ * Returns a flat `(n, 3)` `Float64Array` whose columns are
+ * `[latitudeDeg, longitudeDeg, altitudeKm]` (WGS84). Time-independent.
+ */
+export function ecefToGeodetic(position_km: Float64Array): Float64Array;
+
+/**
+ * Eclipse status for satellite and Sun position batches, km. Returns a
+ * `string[]` of `"sunlit"` / `"penumbra"` / `"umbra"`.
+ */
+export function eclipseStatus(satellite_position_km: Float64Array, sun_position_km: Float64Array): string[];
+
+/**
+ * Effective isotropic radiated power, dBW.
+ */
+export function eirp(tx_power_dbm: number, tx_antenna_gain_dbi: number): number;
+
+/**
+ * Build the encounter frame from two position/velocity states (each a length-3
+ * `Float64Array`).
+ */
+export function encounterFrame(position1_km: Float64Array, velocity1_km_s: Float64Array, position2_km: Float64Array, velocity2_km_s: Float64Array): EncounterFrame;
+
+/**
+ * Project a 3x3 ECI covariance into the encounter B-plane `(x, z)`. Returns a
+ * flat row-major length-4 (2-by-2) `Float64Array`.
+ */
+export function encounterPlaneCovariance(frame: EncounterFrame, covariance_km2: Float64Array): Float64Array;
+
+/**
+ * J2 oblateness gravitational acceleration in km/s^2.
+ *
+ * `positionKm` and `velocityKmS` are length-3 `Float64Array`s in the same
+ * inertial frame; the result is the J2 perturbing acceleration as a length-3
+ * `Float64Array`. Uses the core Earth gravitational parameter, equatorial
+ * radius, and J2 coefficient. Throws a `RangeError` for a non-finite input and
+ * an `Error` for a degenerate (zero-magnitude) position.
+ */
+export function forceJ2Acceleration(position_km: Float64Array, velocity_km_s: Float64Array): Float64Array;
+
+/**
+ * Two-body (point-mass) gravitational acceleration in km/s^2.
+ *
+ * `positionKm` and `velocityKmS` are length-3 `Float64Array`s in the same
+ * inertial frame; the result is a length-3 `Float64Array`. Uses the core
+ * Earth gravitational parameter. Throws a `RangeError` for a non-finite input
+ * and an `Error` for a degenerate (zero-magnitude) position.
+ */
+export function forceTwoBodyAcceleration(position_km: Float64Array, velocity_km_s: Float64Array): Float64Array;
+
+/**
+ * Build GPS identity records from CelesTrak `gps-ops` OMM JSON-array text.
+ *
+ * Parses the CelesTrak JSON array into OMM records, then derives normalized
+ * `Record` rows (sorted by PRN). Returns a `Record[]`. Throws an `Error` on a
+ * JSON parse failure or a CelesTrak object name with no parseable PRN.
+ */
+export function fromCelestrakJson(json: string): any;
+
+/**
+ * Free-space path loss, dB, for range in km and frequency in MHz.
+ */
+export function fspl(distance_km: number, frequency_mhz: number): number;
+
+/**
+ * Ionosphere-free coefficient `gamma = f1^2 / (f1^2 - f2^2)`.
+ */
+export function gamma(f1_hz: number, f2_hz: number): number;
+
+/**
+ * Transform a batch of GCRS positions to ITRS (Earth-fixed / ECEF), each at its
+ * own epoch. Returns a flat row-major `(n, 3)` `Float64Array`.
+ */
+export function gcrsToItrs(position_km: Float64Array, epochs_unix_us: BigInt64Array, skyfield_compat?: boolean | null): Float64Array;
+
+/**
+ * Convert a batch of geodetic coordinates to ITRS (ECEF).
+ *
+ * `geodetic` is a flat row-major `(n, 3)` `Float64Array` whose columns are
+ * `[latitudeDeg, longitudeDeg, altitudeKm]` (WGS84). Returns a flat `(n, 3)`
+ * ITRS `Float64Array` in kilometres. Time-independent.
+ */
+export function geodeticToEcef(geodetic: Float64Array): Float64Array;
+
+/**
+ * Geometry-free phase combination `L_GF = L1 - L2`, metres.
+ */
+export function geometryFree(l1_m: number, l2_m: number): number;
+
+/**
+ * GNSS dilution of precision from ECEF line-of-sight unit rows and weights.
+ *
+ * `lineOfSight` is a flat row-major `(n, 3)` `Float64Array`; `weights` is a
+ * positive `Float64Array` of length `n`.
+ */
+export function gnssDop(line_of_sight: Float64Array, weights: Float64Array, receiver: Wgs84Geodetic): Dop;
+
+/**
+ * Sample SP3-derived GNSS DOP over a J2000 epoch grid.
+ *
+ * `stationEcefM` is an ECEF metre vector (length 3); `j2000Seconds` is a
+ * `Float64Array` grid in the SP3 product time scale. Samples with too few
+ * satellites or singular geometry are omitted. `options` is
+ * `{ satellites?, elevationMaskDeg?=5, systems?, weighting?="unit", lightTime?=false }`.
+ */
+export function gnssDopSeries(sp3: Sp3, station_ecef_m: Float64Array, j2000_seconds: Float64Array, options: any): DopSeries;
+
+/**
+ * Stable lower-case display label for a constellation, e.g. `"gps"`.
+ */
+export function gnssSystemLabel(system: GnssSystem): string;
+
+/**
+ * Canonical RINEX one-letter identifier for a constellation, e.g. `"G"`.
+ */
+export function gnssSystemLetter(system: GnssSystem): string;
+
+/**
+ * Ionosphere-free code or meter-valued phase combination, metres.
+ */
+export function ionosphereFree(obs1_m: number, obs2_m: number, f1_hz: number, f2_hz: number): number;
+
+/**
+ * Ionosphere-free carrier-phase combination from cycle-valued phase inputs.
+ */
+export function ionosphereFreePhaseCycles(phi1_cycles: number, phi2_cycles: number, f1_hz: number, f2_hz: number): number;
+
+/**
+ * Ionosphere-free carrier-phase combination from meter-valued phase inputs.
+ */
+export function ionosphereFreePhaseM(phase1_m: number, phase2_m: number, f1_hz: number, f2_hz: number): number;
+
+/**
+ * Combine two satellite-keyed pseudorange bands into ionosphere-free ranges.
+ * `band1` and `band2` are arrays of `{ satelliteId, valueM }`. `overrides` is
+ * an optional array of `{ system, band1, band2 }` RINEX band selections.
+ */
+export function ionosphereFreePseudoranges(band1: any, band2: any, overrides: any): IonoFreePseudorangeResult;
+
+/**
+ * Returns `true` when a validation report has no findings.
+ */
+export function isValid(validation: any): boolean;
+
+/**
+ * Transform a batch of ITRS (ECEF) positions to GCRS, each at its own epoch.
+ * Returns a flat row-major `(n, 3)` `Float64Array`.
+ */
+export function itrsToGcrs(position_km: Float64Array, epochs_unix_us: BigInt64Array): Float64Array;
+
+/**
+ * Provenance and coverage of the embedded leap-second (TAI-UTC) table.
+ */
+export function leapSecondTableInfo(): LeapSecondTable;
+
+/**
+ * TAI-UTC (cumulative leap seconds) in effect on a UTC calendar date.
+ */
+export function leapSeconds(year: number, month: number, day: number): number;
+
+/**
+ * Leap seconds for a batch of UTC dates, as a `Float64Array`. `dates` is a flat
+ * row-major `(n, 3)` `Int32Array` (or `number[]`) of `[year, month, day]`.
+ */
+export function leapSecondsBatch(dates: Int32Array): Float64Array;
+
+/**
+ * Parse an ANTEX 1.4 antenna product from in-memory bytes (a `Uint8Array`).
+ * Throws an `Error` on a parse failure or non-UTF-8 input.
+ */
+export function loadAntex(bytes: Uint8Array): Antex;
+
+/**
+ * Alias of [`decodeCrinex`] for callers that read a file as bytes.
+ */
+export function loadCrinex(bytes: Uint8Array): string;
+
+/**
+ * Parse an IONEX vertical-TEC product from the full text content (as bytes).
+ * Throws an `Error` on malformed input.
+ */
+export function loadIonex(bytes: Uint8Array): Ionex;
+
+/**
+ * Alias of [`parseRinexClock`] for callers that read a file as bytes.
+ */
+export function loadRinexClock(bytes: Uint8Array): RinexClock;
+
+/**
+ * Alias of [`parseRinexClockLossy`] for callers that read a file as bytes.
+ */
+export function loadRinexClockLossy(bytes: Uint8Array): RinexClock;
+
+/**
+ * Alias of [`parseRinexNav`] for callers that read a file as bytes.
+ */
+export function loadRinexNav(bytes: Uint8Array): BroadcastEphemeris;
+
+/**
+ * Alias of [`parseRinexObs`] for callers that read a file as bytes.
+ */
+export function loadRinexObs(bytes: Uint8Array): RinexObs;
+
+/**
+ * Parse an SP3-c or SP3-d byte buffer (the full, already-decompressed file)
+ * into a precise-ephemeris product. Throws an `Error` on malformed input.
+ */
+export function loadSp3(bytes: Uint8Array): Sp3;
+
+/**
+ * Melbourne-Wubbena combination, metres.
+ */
+export function melbourneWubbena(phi1_cycles: number, phi2_cycles: number, p1_m: number, p2_m: number, f1_hz: number, f2_hz: number): number;
+
+/**
+ * Merge NAVCEN status rows into records by PRN.
+ *
+ * `records` is a `Record[]` (from [`fromCelestrakJson`]); `statuses` is a
+ * `NavcenStatus[]` (from [`parseNavcen`]). Returns the merged `Record[]` sorted
+ * by PRN, filling SVN/usability and NAVCEN provenance on compatible matches.
+ */
+export function mergeNavcen(records: any, statuses: any): any;
+
+/**
+ * Merge SP3 products with the core consensus merge path.
+ *
+ * `sources` is a JS array of parsed [`Sp3`] products, ordered by source
+ * precedence; the handles are consumed. `options` is an optional plain object
+ * (see the `Sp3MergeOptions` TypeScript type). Returns an [`Sp3MergeResult`]
+ * carrying the merged product and the audit report. Throws a `TypeError` for an
+ * empty source list or bad options, and an `Error` for incompatible inputs
+ * (mismatched time systems or coordinate frames).
+ */
+export function mergeSp3(sources: Sp3[], options: any): Sp3MergeResult;
+
+/**
+ * Angle in degrees between satellite nadir and the Moon direction.
+ */
+export function moonAngle(satellite_position_km: Float64Array, moon_position_km: Float64Array): Float64Array;
+
+/**
+ * Narrow-lane code combination, metres.
+ */
+export function narrowLaneCode(p1_m: number, p2_m: number, f1_hz: number, f2_hz: number): number;
+
+/**
+ * Stable lower-case selector for a NAV message, e.g. `"gps_lnav"`.
+ */
+export function navMessageLabel(message: NavMessage): string;
+
+/**
+ * Equal-variance noise amplification of the ionosphere-free combination.
+ */
+export function noiseAmplification(f1_hz: number, f2_hz: number): number;
+
+/**
+ * Stable lower-case label for an observation kind.
+ */
+export function observationKindLabel(kind: ObservationKind): string;
+
+/**
+ * Parse CCSDS CDM KVN text. Throws an `Error` on a parse failure.
+ */
+export function parseCdmKvn(text: string): Cdm;
+
+/**
+ * Parse CCSDS CDM XML text. Throws an `Error` on a parse failure.
+ */
+export function parseCdmXml(text: string): Cdm;
+
+/**
+ * Parse NAVCEN's GPS constellation status HTML into status rows.
+ *
+ * Returns a `NavcenStatus[]` sorted by PRN. Throws an `Error` when the HTML
+ * carries no GPS rows or a required integer cell fails to parse.
+ */
+export function parseNavcen(html: string): any;
+
+/**
+ * Parse CCSDS/CelesTrak OMM JSON text. Throws an `Error` on a parse failure.
+ */
+export function parseOmmJson(text: string): Omm;
+
+/**
+ * Parse CCSDS OMM KVN text. Throws an `Error` on a parse failure.
+ */
+export function parseOmmKvn(text: string): Omm;
+
+/**
+ * Parse CCSDS OMM XML text. Throws an `Error` on a parse failure.
+ */
+export function parseOmmXml(text: string): Omm;
+
+/**
+ * Strictly parse RINEX clock bytes into satellite clock-bias series. Throws a
+ * `TypeError` on non-UTF-8 input and an `Error` on a malformed record.
+ */
+export function parseRinexClock(bytes: Uint8Array): RinexClock;
+
+/**
+ * Parse RINEX clock bytes, skipping malformed and non-`AS` rows. Throws a
+ * `TypeError` only on non-UTF-8 input.
+ */
+export function parseRinexClockLossy(bytes: Uint8Array): RinexClock;
+
+/**
+ * Parse all GLONASS state-vector records from RINEX NAV bytes.
+ */
+export function parseRinexGlonassRecords(bytes: Uint8Array): GlonassRecordJs[];
+
+/**
+ * Parse GPS and BeiDou Klobuchar coefficients from a RINEX NAV header.
+ */
+export function parseRinexIonoCorrections(bytes: Uint8Array): IonoCorrectionsJs;
+
+/**
+ * Parse the NAV header GPS minus UTC leap seconds, or `undefined`.
+ */
+export function parseRinexLeapSeconds(bytes: Uint8Array): number | undefined;
+
+/**
+ * Parse RINEX NAV bytes into the default broadcast ephemeris store. Throws a
+ * `TypeError` on non-UTF-8 input and an `Error` on a parse failure.
+ */
+export function parseRinexNav(bytes: Uint8Array): BroadcastEphemeris;
+
+/**
+ * Parse all supported GPS, Galileo, and BeiDou broadcast records from NAV
+ * bytes, before the store's default health and message-policy filter.
+ */
+export function parseRinexNavRecords(bytes: Uint8Array): BroadcastRecordJs[];
+
+/**
+ * Parse a RINEX OBS byte buffer (UTF-8 text) into an observation product.
+ * Throws a `TypeError` on non-UTF-8 input and an `Error` on a parse failure.
+ */
+export function parseRinexObs(bytes: Uint8Array): RinexObs;
+
+/**
+ * Sun-satellite-observer phase angle in degrees.
+ */
+export function phaseAngle(satellite_position_km: Float64Array, sun_position_km: Float64Array, observer_position_km: Float64Array): Float64Array;
+
+/**
+ * Carrier phase converted to metres, `L = c / f * phi`.
+ */
+export function phaseMeters(phi_cycles: number, f_hz: number): number;
+
+/**
+ * Numerically propagate an ECI Cartesian state and sample it at a grid of
+ * epochs.
+ *
+ * `request` is a plain object; see the `PropagateStateRequest` TypeScript type.
+ * Throws a `TypeError` for malformed input (wrong shape, unknown selector), a
+ * `RangeError` for a non-positive initial step, and an `Error` if the engine's
+ * propagation fails.
+ */
+export function propagateState(request: any): Ephemeris;
+
+/**
+ * Stable lower-case label for a pseudorange drop reason.
+ */
+export function pseudorangeDropReasonLabel(reason: PseudorangeDropReason): string;
+
+/**
+ * Pseudorange measurement variance, square metres.
+ */
+export function pseudorangeVariance(elevation_deg: number, options: any): number;
+
+/**
+ * Convert a pseudorange rate in metres per second to Doppler shift in hertz.
+ */
+export function rangeRateToDoppler(range_rate_m_s: number, carrier_hz: number): number;
+
+/**
+ * Build a sampled GPS C/A code replica, an `Int8Array`.
+ */
+export function replica(prn: bigint, options: any): Int8Array;
+
+/**
+ * RINEX observation band frequency in hertz for a system and band digit.
+ */
+export function rinexBandFrequencyHz(system: GnssSystem, band: string, glonass_channel?: number | null): number | undefined;
+
+/**
+ * RINEX observation band wavelength in metres for a system and band digit.
+ */
+export function rinexBandWavelengthM(system: GnssSystem, band: string, glonass_channel?: number | null): number | undefined;
+
+/**
+ * Transform a 3x3 RTN covariance (flat row-major length 9) to ECI for the given
+ * orbit state. Returns a flat row-major length-9 `Float64Array`.
+ */
+export function rtnToEciCovariance(covariance_rtn: Float64Array, position_km: Float64Array, velocity_km_s: Float64Array): Float64Array;
+
+/**
+ * Select an IONEX product usable at `requestedEpochJ2000S`, degrading to a
+ * diurnal-shifted prior product within `policy`.
+ *
+ * `products` is a JS array of parsed [`Ionex`] handles (consumed). `policy` is
+ * optional (`{ maxStalenessS }` or `{ maxStalenessDays }`, default 3 days).
+ * Throws a typed selection `Error` when no product fits the request and cap.
+ */
+export function selectIonex(products: Ionex[], requested_epoch_j2000_s: number, policy: any): IonexSelection;
+
+/**
+ * Select an IONEX product usable across `[startEpochJ2000S, endEpochJ2000S]`.
+ * See [`selectIonex`] for the single-epoch case and the arguments.
+ */
+export function selectIonexOverRange(products: Ionex[], start_epoch_j2000_s: number, end_epoch_j2000_s: number, policy: any): IonexSelection;
+
+/**
+ * Select an SP3 product usable at `requestedEpochJ2000S`, degrading to the
+ * most-recent prior product within `policy`. See [`selectIonex`] for the
+ * `products` / `policy` conventions.
+ */
+export function selectSp3(products: Sp3[], requested_epoch_j2000_s: number, policy: any): Sp3Selection;
+
+/**
+ * Select an SP3 product usable across `[startEpochJ2000S, endEpochJ2000S]`.
+ */
+export function selectSp3OverRange(products: Sp3[], start_epoch_j2000_s: number, end_epoch_j2000_s: number, policy: any): Sp3Selection;
+
+/**
+ * Shadow fraction in `[0, 1]` for satellite and Sun position batches, km.
+ *
+ * `satellitePositionKm` and `sunPositionKm` are flat row-major `(n, 3)`
+ * `Float64Array`s. Returns a `Float64Array` of length `n`.
+ */
+export function shadowFraction(satellite_position_km: Float64Array, sun_position_km: Float64Array): Float64Array;
+
+/**
+ * Build satellite-keyed pseudorange sigmas in metres from `{ satelliteId,
+ * elevationDeg, cn0Dbhz? }` entries. Invalid entries are dropped by the core.
+ */
+export function sigmas(entries: any, options: any): SatelliteVector;
+
+/**
+ * Stable lower-case label for a slip reason.
+ */
+export function slipReasonLabel(reason: SlipReason): string;
+
+/**
+ * Single-frequency Hatch carrier-smoothed code on band 1.
+ */
+export function smoothCode(arc: any, options: any, hatch_window_cap?: number | null): SmoothCodeResult[];
+
+/**
+ * Dual-frequency ionosphere-free Hatch carrier-smoothed code.
+ */
+export function smoothIonoFreeCode(arc: any, options: any, hatch_window_cap?: number | null): IonoFreeSmoothResult[];
+
+/**
+ * Post-correlation predetection SNR in decibels.
+ */
+export function snrPostDb(cn0_dbhz: number, integration_time_s: number): number;
+
+/**
+ * Search integer ambiguities from a float PPP solution and re-solve fixed.
+ *
+ * `epochs` and `config` are plain objects (`PppEpoch`, `PppFixedConfig`);
+ * `floatSolution` is the result of [`solvePppFloat`] over the same arc. Throws
+ * a `TypeError` for malformed input and an `Error` if the solve fails.
+ */
+export function solvePppFixed(sp3: Sp3, epochs: any, float_solution: PppFloatSolution, config: any): PppFixedSolution;
+
+/**
+ * Solve a static multi-epoch float PPP arc against an SP3 product.
+ *
+ * `epochs`, `initialState`, and `config` are plain objects; see the
+ * `PppEpoch`, `PppFloatState`, and `PppFloatConfig` TypeScript types. Throws a
+ * `TypeError` for malformed input and an `Error` if the solve fails.
+ */
+export function solvePppFloat(sp3: Sp3, epochs: any, initial_state: any, config: any): PppFloatSolution;
+
+/**
+ * Solve a static fixed RTK baseline with residual validation / FDE.
+ *
+ * `config` is a plain object; see the `RtkFixedConfig` TypeScript type. Throws
+ * a `TypeError` for malformed input and an `Error` if the solve fails.
+ */
+export function solveRtkFixed(config: any): RtkFixedSolution;
+
+/**
+ * Solve a static float RTK baseline.
+ *
+ * `config` is a plain object; see the `RtkFloatConfig` TypeScript type. Throws
+ * a `TypeError` for malformed input and an `Error` if the solve fails.
+ */
+export function solveRtkFloat(config: any): RtkFloatSolution;
+
+/**
+ * Solve receiver ECEF velocity and clock drift from one epoch of observations.
+ * `observations` is an array of `{ satelliteId, value, carrierHz,
+ * satClockDriftSS? }`; `receiverEcefM` is a length-3 `Float64Array`.
+ */
+export function solveVelocity(sp3: Sp3, observations: any, receiver_ecef_m: Float64Array, t_rx_j2000_s: number, options: any): VelocitySolution;
+
+/**
+ * Solve a receiver position, preferring precise SP3 products and falling back to
+ * broadcast ephemeris, reporting which source was used and how stale it is.
+ *
+ * `precise` is a JS array of parsed [`Sp3`] handles (consumed); the staleness
+ * layer selects among them at the request's receive epoch. `broadcast` is the
+ * broadcast store used when no precise product covers the epoch within `policy`.
+ * `request` is the SPP request object [`Sp3.solveSpp`] takes. Returns a
+ * [`SourcedSolution`]; throws a typed fallback `Error` if the chosen path's
+ * solve fails.
+ */
+export function solveWithFallback(precise: Sp3[], broadcast: BroadcastEphemeris, request: any, policy: any): SourcedSolution;
+
+/**
+ * Angle in degrees between satellite nadir and the Sun direction.
+ */
+export function sunAngle(satellite_position_km: Float64Array, sun_position_km: Float64Array): Float64Array;
+
+/**
+ * Sun elevation in degrees above the satellite local horizontal plane.
+ */
+export function sunElevation(satellite_position_km: Float64Array, sun_position_km: Float64Array): Float64Array;
+
+/**
+ * Analytic Sun and Moon geocentric positions in the Earth-fixed ITRS (ECEF)
+ * frame, metres, for a `BigInt64Array` of unix-microsecond epochs.
+ */
+export function sunMoonEcef(epochs_unix_us: BigInt64Array): SunMoon;
+
+/**
+ * Analytic Sun and Moon positions in the geocentric ECI frame (mean equator and
+ * equinox of date), metres, for a `BigInt64Array` of unix-microsecond epochs.
+ */
+export function sunMoonEci(epochs_unix_us: BigInt64Array): SunMoon;
+
+/**
+ * Transform a batch of TEME states to GCRS, each at its own epoch.
+ *
+ * `positionKm` and `velocityKmS` are flat row-major `(n, 3)` `Float64Array`s;
+ * `epochsUnixUs` is a `BigInt64Array` of unix-microsecond UTC stamps.
+ * `skyfieldCompat` (default true) selects the AU-scaled Skyfield-parity path.
+ */
+export function temeToGcrs(position_km: Float64Array, velocity_km_s: Float64Array, epochs_unix_us: BigInt64Array, skyfield_compat?: boolean | null): FrameStates;
+
+/**
+ * Short uppercase identifier for a time scale, e.g. `"GPST"`.
+ */
+export function timeScaleAbbrev(scale: TimeScale): string;
+
+/**
+ * Export records as the compact mapping CSV (`prn,norad_cat_id,active,sp3_id`).
+ *
+ * `booleans` selects the `active` column rendering: `"lower"` (default) for
+ * `true`/`false`, `"title"` for `True`/`False`.
+ */
+export function toCsv(records: any, booleans?: string | null): string;
+
+/**
+ * Niell hydrostatic and wet mapping factors at an elevation.
+ *
+ * `elevationDeg` and `latDeg` are degrees, `heightM` the WGS84 ellipsoidal
+ * height in metres, and (`jdWhole`, `jdFraction`) a split Julian date for the
+ * seasonal day-of-year. Unity at the zenith; grows toward the horizon.
+ */
+export function tropoMappingFactors(elevation_deg: number, lat_deg: number, height_m: number, jd_whole: number, jd_fraction: number): MappingFactors;
+
+/**
+ * Full slant tropospheric delay, positive metres.
+ *
+ * Composes the Saastamoinen zenith delays with the Niell mapping at
+ * `elevationDeg`. The receiver is `latDeg` / `lonDeg` / `heightM`; `met` is the
+ * `{ pressureHpa, temperatureK, relativeHumidity }` object; (`jdWhole`,
+ * `jdFraction`) the split Julian date. Returns `0` at or below the horizon
+ * (no signal path), matching the cross-binding contract.
+ */
+export function tropoSlantDelay(elevation_deg: number, lat_deg: number, lon_deg: number, height_m: number, met: any, jd_whole: number, jd_fraction: number): number;
+
+/**
+ * Saastamoinen zenith tropospheric delays from supplied meteorology.
+ *
+ * `latDeg` is the receiver geodetic latitude in degrees, `heightM` the WGS84
+ * ellipsoidal height in metres, and `met` a `{ pressureHpa, temperatureK,
+ * relativeHumidity }` object. The hydrostatic term carries the latitude/height
+ * gravity correction. Throws a `RangeError`/`Error` for out-of-domain input.
+ */
+export function tropoZenithDelay(lat_deg: number, height_m: number, met: any): ZenithDelay;
+
+/**
+ * Provenance and coverage of the embedded UT1-UTC / delta-T (EOP) table.
+ */
+export function ut1CoverageInfo(): Ut1Coverage;
+
+/**
+ * Validate catalog identity without an SP3 product.
+ *
+ * Returns a `Validation` reporting duplicate PRNs, duplicate NORAD ids, and
+ * inactive/unusable PRNs.
+ */
+export function validate(records: any): any;
+
+/**
+ * Validate catalog identity against a list of SP3/RINEX satellite tokens.
+ *
+ * Returns a `Validation` that additionally reports active+usable catalog ids
+ * missing from `ids` and GPS ids in `ids` absent from the active+usable catalog.
+ */
+export function validateAgainstSp3Ids(records: any, ids: any): any;
+
+/**
+ * Wavelength, metres, for frequency in Hz.
+ */
+export function wavelength(frequency_hz: number): number;
+
+/**
+ * Carrier wavelength in metres for a constellation and canonical carrier band.
+ */
+export function wavelengthM(system: GnssSystem, band: CarrierBand): number | undefined;
+
+/**
+ * Build satellite-keyed inverse-variance pseudorange weights.
+ */
+export function weightVector(entries: any, options: any): SatelliteVector;
+
+/**
+ * Melbourne-Wubbena wide-lane ambiguity estimate, wide-lane cycles.
+ */
+export function wideLaneCycles(phi1_cycles: number, phi2_cycles: number, p1_m: number, p2_m: number, f1_hz: number, f2_hz: number): number;
+
+/**
+ * Wide-lane wavelength `c / (f1 - f2)`, metres.
+ */
+export function wideLaneWavelength(f1_hz: number, f2_hz: number): number;