@neilberkman/sidereon 0.24.0 → 0.25.0

package/pkg-node/sidereon.d.ts

@@ -1,6 +1,555 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/* sidereon typed JsValue overlay */
+export type Vec3 = [number, number, number] | Float64Array;
+export type Vec4 = [number, number, number, number] | Float64Array;
+export type Matrix3 = number[] | Float64Array;
+
+export interface SurfaceMetInput {
+    pressureHpa: number;
+    temperatureK: number;
+    relativeHumidity: number;
+}
+
+export interface RobustOptions {
+    huberK?: number;
+    scaleFloorM?: number;
+    maxOuter?: number;
+    outerTolM?: number;
+}
+
+export interface SppObservation {
+    satelliteId: string;
+    pseudorangeM: number;
+}
+
+export interface SppCorrections {
+    ionosphere?: boolean;
+    troposphere?: boolean;
+}
+
+export interface SppRequest {
+    observations: SppObservation[];
+    tRxJ2000S: number;
+    tRxSecondOfDayS: number;
+    dayOfYear: number;
+    initialGuess?: Vec4;
+    corrections?: SppCorrections;
+    klobuchar?: { alpha?: Vec4; beta?: Vec4 };
+    met?: SurfaceMetInput;
+    glonassChannels?: Array<[number, number]>;
+    withGeodetic?: boolean;
+    robust?: RobustOptions;
+    coarseSearchSeeds?: number;
+    maxPdop?: number;
+}
+
+export interface FdeRequest extends SppRequest {
+    pFa?: number;
+    weights?: Array<{ satelliteId: string; weight: number }>;
+    nSystems?: number;
+    maxIterations?: number;
+}
+
+export interface SppBatchOptions {
+    withGeodetic?: boolean;
+    coarseSearchSeeds?: number;
+    maxPdop?: number;
+}
+
+export interface RinexSppOptions {
+    signalPolicy?: Record<string, string[]>;
+    corrections?: SppCorrections;
+    initialGuess?: Vec4;
+    satellites?: string[];
+    met?: SurfaceMetInput;
+    robust?: RobustOptions;
+}
+
+export type RinexSppSolveOptions = SppBatchOptions;
+
+export interface RinexSppEpochTime {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+}
+
+export interface RinexSppEpochInputs {
+    epochIndex: number;
+    epoch: RinexSppEpochTime;
+    observations: SppObservation[];
+    tRxJ2000S: number;
+    tRxSecondOfDayS: number;
+    dayOfYear: number;
+    initialGuess: [number, number, number, number];
+    corrections: Required<SppCorrections>;
+    glonassChannels: Array<[number, number]>;
+}
+
+export interface RaimInput {
+    usedSats: string[];
+    residualsM: number[] | Float64Array;
+}
+
+export type RaimWeightsInput =
+    | { satelliteIds: string[]; weights: number[] | Float64Array }
+    | { satelliteIds: string[]; values: number[] | Float64Array }
+    | Array<{ satelliteId: string; weight: number }>
+    | Record<string, number>;
+
+export interface RaimOptions {
+    pFa?: number;
+    weights?: RaimWeightsInput | RaimWeights;
+    weightEntries?: Array<{ satelliteId: string; elevationDeg: number; cn0Dbhz?: number }>;
+    varianceOptions?: { aM?: number; bM?: number; model?: "elevation" | "elevation_cn0"; cn0Dbhz?: number; cn0ScaleM2?: number };
+    nSystems?: number;
+}
+
+export interface RaimResult {
+    faultDetected: boolean;
+    testStatistic: number;
+    threshold: number | null;
+    worstSat: string | null;
+    reducedChiSquare: number | null;
+    normalizedResiduals: Record<string, number>;
+    rmsM: number;
+    dof: number;
+}
+
+export interface RangeFdeRow {
+    id: string;
+    residualM: number;
+    designRow: number[] | Float64Array;
+    weight: number;
+}
+
+export interface RangeFdeOptions {
+    pFa?: number;
+    maxExclusions?: number;
+    minRedundancy?: number;
+}
+
+export interface RangeFdeResult {
+    stateCorrection: number[];
+    stateCovariance: number[][];
+    globalTest: { weightedSumSquares: number; dof: number; threshold: number | null; testable: boolean; faultDetected: boolean };
+    excluded: string[];
+    diagnostics: Array<{ id: string; excluded: boolean; postFitResidualM: number; normalizedResidual: number }>;
+    iterations: number;
+}
+
+export interface AraimReceiver {
+    latRad: number;
+    lonRad: number;
+    heightM: number;
+}
+
+export interface AraimRow {
+    id: string;
+    lineOfSight: [number, number, number] | Float64Array;
+    system?: string;
+    elevationRad: number;
+}
+
+export interface AraimGeometry {
+    rows: AraimRow[];
+    receiver: AraimReceiver;
+    clockSystems: string[];
+}
+
+export interface AraimSatelliteIsmModel {
+    sigmaUraM: number;
+    sigmaUreM: number;
+    effectiveSigmaIntM?: number;
+    effectiveSigmaAccM?: number;
+    bNomM: number;
+    pSat: number;
+}
+
+export interface AraimConstellationIsm {
+    system: string;
+    pConst: number;
+    defaultSat: AraimSatelliteIsmModel;
+}
+
+export interface AraimSatelliteIsm extends AraimSatelliteIsmModel {
+    id: string;
+}
+
+export interface AraimIsm {
+    constellations: AraimConstellationIsm[];
+    satellites?: AraimSatelliteIsm[];
+}
+
+export interface AraimAllocation {
+    phmiTotal: number;
+    phmiVert: number;
+    phmiHor: number;
+    pfaVert: number;
+    pfaHor: number;
+    pThresholdUnmonitored: number;
+    pEmt?: number;
+    maxFaultOrder: number;
+}
+
+export interface AraimFaultHypothesis {
+    excluded: string[];
+    excludedConstellation: string | null;
+    prior: number;
+}
+
+export interface AraimFaultMode extends AraimFaultHypothesis {
+    sigmaIntEnuM: [number, number, number];
+    biasEnuM: [number, number, number];
+    thresholdEnuM: [number, number, number];
+    monitorable: boolean;
+}
+
+export interface AraimResult {
+    available: boolean;
+    hplM: number;
+    vplM: number;
+    sigmaAccHM: number;
+    sigmaAccVM: number;
+    emtM: number;
+    faultModes: AraimFaultMode[];
+    pUnmonitored: number;
+    availability: boolean;
+}
+
+export interface RtkSignalPair {
+    system?: string;
+    codeObservable: string;
+    phaseObservable: string;
+}
+
+export interface RtkDualSignalPair {
+    system?: string;
+    code1Observable: string;
+    phase1Observable: string;
+    code2Observable: string;
+    phase2Observable: string;
+}
+
+export interface RtkRinexArcOptions {
+    signalPairs?: RtkSignalPair[];
+    maxEpochs?: number;
+    minCommonSatellites?: number;
+    includePredictionTime?: boolean;
+}
+
+export interface RtkRinexDualArcOptions {
+    signalPairs?: RtkDualSignalPair[];
+    maxEpochs?: number;
+    minCommonSatellites?: number;
+    includePredictionTime?: boolean;
+}
+
+export interface RtkArcObservation {
+    satelliteId: string;
+    roverCodeM: number;
+    baseCodeM: number;
+    roverPhaseCycles: number;
+    basePhaseCycles: number;
+    wavelengthM: number;
+    elevationRad?: number;
+}
+
+export interface RtkArcEpoch {
+    tRxJ2000S: number;
+    observations: RtkArcObservation[];
+}
+
+export interface RtkMeasModel {
+    codeSigmaM?: number;
+    phaseSigmaM?: number;
+    sagnac?: boolean;
+    stochastic?: string | { kind: string; elevationWeighting?: boolean };
+}
+
+export interface RtkArcConfig {
+    baseM: Vec3;
+    reference?: string | { kind: string; satelliteId?: string };
+    model?: RtkMeasModel;
+    baselinePriorSigmaM?: number;
+    ambiguityPriorSigmaM?: number;
+    initialBaselineM?: Vec3;
+    wavelengthsM?: Record<string, number>;
+    offsetsM?: Record<string, number>;
+    updateOpts?: Record<string, number | boolean>;
+    preprocessing?: Record<string, number | boolean | string[]>;
+}
+
+export interface RtkStaticArcConfig {
+    arc: RtkArcConfig;
+    opts?: Record<string, number | boolean>;
+}
+
+export interface RtkArcSolution {
+    epochs: Array<Record<string, number | string | boolean | string[] | number[] | null>>;
+    finalState: Record<string, number | number[] | Record<string, number>>;
+    references: Record<string, string>;
+}
+
+export interface RtkStaticArcSolution {
+    float: Record<string, number | string | boolean | string[] | number[] | Record<string, number> | null>;
+    fixed: Record<string, number | string | boolean | string[] | number[] | Record<string, number> | null>;
+}
+
+export interface RtkDualFrequencyObservation {
+    satelliteId: string;
+    roverCode1M: number;
+    baseCode1M: number;
+    roverPhase1Cycles: number;
+    basePhase1Cycles: number;
+    roverCode2M: number;
+    baseCode2M: number;
+    roverPhase2Cycles: number;
+    basePhase2Cycles: number;
+    freq1Hz: number;
+    freq2Hz: number;
+    elevationRad?: number;
+}
+
+export interface RtkDualFrequencyArcEpoch {
+    tRxJ2000S: number;
+    observations: RtkDualFrequencyObservation[];
+}
+
+export interface RtkWideLaneArcConfig extends RtkArcConfig {
+    options?: Record<string, number | boolean>;
+}
+
+export interface RtkWideLaneFixedResult {
+    wideLaneCycles: Record<string, number>;
+    metadata: Record<string, number | string | boolean>;
+    solutions?: Array<Record<string, number | string | boolean | number[] | Record<string, number>>>;
+}
+
+export interface RtkIonosphereFreeArcConfig extends RtkArcConfig {
+    options?: Record<string, number | boolean>;
+}
+
+export interface RtkIonosphereFreeArcResult {
+    epochs: RtkArcEpoch[];
+    wavelengthsM: Record<string, number>;
+    offsetsM: Record<string, number>;
+}
+
+export interface PppCivil {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+}
+
+export interface PppObservation {
+    satelliteId: string;
+    ambiguityId: string;
+    codeM: number;
+    phaseM: number;
+    freq1Hz?: number;
+    freq2Hz?: number;
+    glonassChannel?: number;
+}
+
+export interface PppEpoch {
+    civil: PppCivil;
+    jdWhole: number;
+    jdFraction: number;
+    tRxJ2000S: number;
+    observations: PppObservation[];
+}
+
+export interface PppFloatState {
+    positionM: Vec3;
+    clocksM: number[];
+    ambiguitiesM: Record<string, number>;
+    ztdM?: number;
+    tropoGradientNorthM?: number;
+    tropoGradientEastM?: number;
+    residualIonosphereM?: Record<string, number>;
+}
+
+export interface PppWeights {
+    code?: number;
+    phase?: number;
+    elevationWeighting?: boolean;
+}
+
+export interface PppTroposphere {
+    enabled?: boolean;
+    estimateZtd?: boolean;
+    estimateTropoGradients?: boolean;
+    pressureHpa?: number;
+    temperatureK?: number;
+    relativeHumidity?: number;
+    vmf1?: Array<{ mjd: number; ah: number; aw: number }>;
+}
+
+export interface PppSolveOptions {
+    maxIterations?: number;
+    positionToleranceM?: number;
+    clockToleranceM?: number;
+    ambiguityToleranceM?: number;
+    ztdToleranceM?: number;
+}
+
+export interface PppFloatConfig {
+    weights?: PppWeights;
+    tropo?: PppTroposphere;
+    options?: PppSolveOptions;
+    elevationCutoffDeg?: number;
+    residualScreen?: boolean;
+    estimateResidualIonosphere?: boolean;
+}
+
+export interface PppFixedAmbiguity {
+    wavelengthsM: Record<string, number>;
+    offsetsM: Record<string, number>;
+    ratioThreshold?: number;
+}
+
+export interface PppFixedConfig {
+    ambiguity: PppFixedAmbiguity;
+    weights?: PppWeights;
+    tropo?: PppTroposphere;
+    options?: PppSolveOptions;
+    elevationCutoffDeg?: number;
+    estimateResidualIonosphere?: boolean;
+}
+
+export interface PppAutoInitOptions {
+    initialGuess?: { positionM: Vec3; clockM: number };
+    sppInitialGuess?: Vec4;
+    sppTroposphere?: boolean;
+    sppMet?: SurfaceMetInput;
+}
+
+export interface PppResidual {
+    epochIndex: number;
+    satelliteId: string;
+    codeM: number;
+    phaseM: number;
+    codeWeight: number;
+    phaseWeight: number;
+}
+
+export interface PppTemporalCorrelation {
+    lag1Autocorrelation: number;
+    decorrelationTimeEpochs: number;
+    decorrelationTimeS: number | null;
+    nominalSampleCount: number;
+    effectiveSampleCount: number;
+    varianceInflationFactor: number;
+    arcsUsed: number;
+}
+
+export type PppScalarMap = Record<string, number>;
+
+export interface FusionConfig {
+    filterKind?: "ekf" | "ukf";
+    initialState?: Record<string, number | number[]>;
+    processNoise?: Record<string, number>;
+    leverArmBodyM?: Vec3;
+    timeSync?: FusionTimeSyncConfig;
+}
+
+export interface FusionTimeSyncConfig {
+    maxRetainedSamples?: number;
+    maxRetainedEpochs?: number;
+}
+
+export interface ImuSampleInput {
+    dtS: number;
+    accelMps2?: Vec3;
+    gyroRadS?: Vec3;
+    deltaVelocityMps?: Vec3;
+    deltaAngleRad?: Vec3;
+}
+
+export interface FusionLooseMeasurement {
+    epochJ2000S?: number;
+    positionM: Vec3;
+    velocityMps?: Vec3;
+    positionCovarianceM2?: Matrix3;
+    velocityCovarianceM2?: Matrix3;
+}
+
+export interface FusionTightEpoch {
+    observations: SppObservation[];
+    tRxJ2000S: number;
+    tRxSecondOfDayS: number;
+    dayOfYear: number;
+    corrections?: SppCorrections;
+    met?: SurfaceMetInput;
+}
+
+export interface FusionUpdate {
+    accepted: boolean;
+    normalizedInnovationSquared?: number;
+    reason?: string;
+}
+
+export interface FusionState {
+    epochJ2000S?: number;
+    positionM: [number, number, number];
+    velocityMps: [number, number, number];
+    attitudeQuaternion?: [number, number, number, number];
+    covariance?: number[];
+}
+
+export interface FusionTimeSyncStatus {
+    retainedSamples: number;
+    retainedEpochs: number;
+    maxRetainedSamples: number;
+    maxRetainedEpochs: number;
+}
+
+export interface FusionRtsEpoch {
+    epochJ2000S: number;
+    state: FusionState;
+}
+
+export interface DllJitterOptions {
+    cn0DbHz: number;
+    receiverBandwidthHz: number;
+    earlyLateSpacingChips: number;
+    integrationTimeS?: number;
+}
+
+export interface DllJitterResult {
+    sigmaChips: number;
+    sigmaM: number;
+}
+
+export interface MultipathEnvelopeOptions {
+    earlyLateSpacingChips: number;
+    receiverBandwidthHz: number;
+    relativeAmplitude?: number;
+    carrierPhaseRad?: number;
+}
+
+export interface MultipathEnvelopeResult {
+    delayChips: Float64Array;
+    errorChips: Float64Array;
+}
+
+export interface TerrainLookupOptions {
+    interpolation?: "bilinear" | "nearest" | "nearestPosting";
+}
+
+export type TerrainPoint = [number, number] | { longitudeDeg: number; latitudeDeg: number };
+export type TerrainHeightBatchResult = { ok: true; heightM: number } | { ok: false; error: string };
+export type TerrainOrthometricBatchResult = { ok: true; orthometricHeightM: OrthometricHeightM } | { ok: false; error: string };
+
+
 /**
  * Acquisition search-grid metadata.
  */
@@ -333,6 +882,14 @@ export class BroadcastEphemeris {
      * J2000 seconds. Returns `undefined` when no usable record covers the query.
      */
     evaluate(satellite: string, t_j2000_s: number): BroadcastStoreEvaluation | undefined;
+    /**
+     * Run fault detection and exclusion against this broadcast ephemeris.
+     *
+     * `request` is the SPP solve request plus the RAIM/exclusion options, the
+     * same object accepted by `Sp3.fde`. Delegates to
+     * `sidereon_core::quality::fde_spp` over the broadcast store.
+     */
+    fde(request: FdeRequest): FdeSolution;
     /**
      * Query ECEF position and clock for parallel satellite and epoch arrays
      * against this parsed broadcast ephemeris store.
@@ -358,7 +915,7 @@ export class BroadcastEphemeris {
      * SPP request object [`Sp3.solveSpp`] takes. The result is identical to
      * solving against this broadcast store as an ephemeris source.
      */
-    solveBroadcast(request: any): SppSolution;
+    solveBroadcast(request: SppRequest): SppSolution;
     /**
      * Serialize the usable GPS, Galileo, and BeiDou broadcast records to
      * standard RINEX 3 navigation text. Deterministic: the same record set
@@ -1613,7 +2170,7 @@ export class DtedTerrain {
      * index-aligned to `points`; each entry is `{ ok: true, heightM }` or
      * `{ ok: false, error }`. Missing tiles evaluate to `0.0`.
      */
-    heightBatch(points: any, options: any): any;
+    heightBatch(points: TerrainPoint[], options?: TerrainLookupOptions | null): TerrainHeightBatchResult[];
     /**
      * Terrain height in ORTHOMETRIC meters at `(longitudeDeg, latitudeDeg)`.
      *
@@ -1629,7 +2186,7 @@ export class DtedTerrain {
      * `"bilinear"`, `"nearest"`, or `"nearestPosting"`. Missing tiles evaluate
      * to `0.0`, matching the core DTED fallback.
      */
-    heightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): number;
+    heightMWithOptions(longitude_deg: number, latitude_deg: number, options?: TerrainLookupOptions | null): number;
     /**
      * Create a DTED terrain reader rooted at `root`.
      *
@@ -2056,7 +2613,7 @@ export class FusionRtsHistory {
     /**
      * Recorded epochs in forward time order.
      */
-    readonly epochs: any;
+    readonly epochs: FusionRtsEpoch[];
 }
 
 /**
@@ -2367,7 +2924,7 @@ export class GnssInsFilter {
     /**
      * Replace retained-history capacities for later time-sync replay.
      */
-    configureTimeSync(config: any): void;
+    configureTimeSync(config: FusionTimeSyncConfig): void;
     /**
      * Encode the current fusion state with the core versioned binary codec.
      */
@@ -2375,23 +2932,23 @@ export class GnssInsFilter {
     /**
      * Build a filter, then restore its state from versioned fusion-state bytes.
      */
-    static fromStateBytes(config: any, bytes: Uint8Array): GnssInsFilter;
+    static fromStateBytes(config: FusionConfig, bytes: Uint8Array): GnssInsFilter;
     /**
      * Build a filter from a JS configuration object.
      */
-    constructor(config: any);
+    constructor(config: FusionConfig);
     /**
      * Propagate the filter with one IMU rate or increment sample.
      */
-    propagate(sample: any): any;
+    propagate(sample: ImuSampleInput): FusionState;
     /**
      * Propagate the filter with a JS array of IMU samples.
      */
-    propagateBatch(samples: any): any;
+    propagateBatch(samples: ImuSampleInput[]): FusionState[];
     /**
      * Propagate and record the transition for later fusion RTS smoothing.
      */
-    propagateRecorded(sample: any, history: FusionRtsHistoryBuilder): any;
+    propagateRecorded(sample: ImuSampleInput, history: FusionRtsHistoryBuilder): FusionState;
     /**
      * Restore this filter from versioned fusion-state bytes.
      */
@@ -2399,67 +2956,67 @@ export class GnssInsFilter {
     /**
      * Current INS state, covariance, and last body-rate diagnostic.
      */
-    state(): any;
+    state(): FusionState;
     /**
      * Current tight-coupling receiver-clock state.
      */
-    tightClockState(): any;
+    tightClockState(): Record<string, number>;
     /**
      * Current retained-history capacity and occupancy.
      */
-    timeSyncStatus(): any;
+    timeSyncStatus(): FusionTimeSyncStatus;
     /**
      * Apply a loose position or position-velocity GNSS fix at the current epoch.
      */
-    updateLoose(measurement: any): any;
+    updateLoose(measurement: FusionLooseMeasurement): FusionUpdate;
     /**
      * Apply a loose GNSS fix and record checkpoints for fusion RTS smoothing.
      */
-    updateLooseRecorded(measurement: any, history: FusionRtsHistoryBuilder): any;
+    updateLooseRecorded(measurement: FusionLooseMeasurement, history: FusionRtsHistoryBuilder): FusionUpdate;
     /**
      * Apply a loose GNSS fix, replaying retained IMU checkpoints when it is late.
      */
-    updateLooseTimeSync(measurement: any): any;
+    updateLooseTimeSync(measurement: FusionLooseMeasurement): FusionUpdate;
     /**
      * Apply a gated wheeled-vehicle non-holonomic constraint update.
      */
-    updateNonHolonomic(): any;
+    updateNonHolonomic(): FusionUpdate;
     /**
      * Apply a non-holonomic constraint and record checkpoints when an update applies.
      */
-    updateNonHolonomicRecorded(history: FusionRtsHistoryBuilder): any;
+    updateNonHolonomicRecorded(history: FusionRtsHistoryBuilder): FusionUpdate;
     /**
      * Apply a gated zero-velocity and zero-angular-rate update.
      */
-    updateStationary(): any;
+    updateStationary(): FusionUpdate;
     /**
      * Apply a stationary update and record checkpoints when an update applies.
      */
-    updateStationaryRecorded(history: FusionRtsHistoryBuilder): any;
+    updateStationaryRecorded(history: FusionRtsHistoryBuilder): FusionUpdate;
     /**
      * Apply a tight raw-observation epoch against a broadcast ephemeris source.
      */
-    updateTightBroadcast(broadcast: BroadcastEphemeris, epoch: any): any;
+    updateTightBroadcast(broadcast: BroadcastEphemeris, epoch: FusionTightEpoch): FusionUpdate;
     /**
      * Apply a tight broadcast update and record checkpoints for fusion RTS smoothing.
      */
-    updateTightBroadcastRecorded(broadcast: BroadcastEphemeris, epoch: any, history: FusionRtsHistoryBuilder): any;
+    updateTightBroadcastRecorded(broadcast: BroadcastEphemeris, epoch: FusionTightEpoch, history: FusionRtsHistoryBuilder): FusionUpdate;
     /**
      * Apply a tight broadcast update, replaying retained IMU checkpoints when it is late.
      */
-    updateTightBroadcastTimeSync(broadcast: BroadcastEphemeris, epoch: any): any;
+    updateTightBroadcastTimeSync(broadcast: BroadcastEphemeris, epoch: FusionTightEpoch): FusionUpdate;
     /**
      * Apply a tight raw-observation epoch against an SP3 source.
      */
-    updateTightSp3(sp3: Sp3, epoch: any): any;
+    updateTightSp3(sp3: Sp3, epoch: FusionTightEpoch): FusionUpdate;
     /**
      * Apply a tight SP3 update and record checkpoints for fusion RTS smoothing.
      */
-    updateTightSp3Recorded(sp3: Sp3, epoch: any, history: FusionRtsHistoryBuilder): any;
+    updateTightSp3Recorded(sp3: Sp3, epoch: FusionTightEpoch, history: FusionRtsHistoryBuilder): FusionUpdate;
     /**
      * Apply a tight SP3 update, replaying retained IMU checkpoints when it is late.
      */
-    updateTightSp3TimeSync(sp3: Sp3, epoch: any): any;
+    updateTightSp3TimeSync(sp3: Sp3, epoch: FusionTightEpoch): FusionUpdate;
 }
 
 /**
@@ -3512,12 +4069,12 @@ export class MmapTerrain {
      * the EGM96 15-arcminute model requires a loaded `WW15MGH.DAC` grid and
      * does not fall back to the embedded 1-degree grid.
      */
-    ellipsoidalHeightMWithModel(longitude_deg: number, latitude_deg: number, options: any, geoid: TerrainGeoidModel): EllipsoidalHeightM;
+    ellipsoidalHeightMWithModel(longitude_deg: number, latitude_deg: number, options: TerrainLookupOptions | null | undefined, geoid: TerrainGeoidModel): EllipsoidalHeightM;
     /**
      * Ellipsoidal height `h = H + N` in metres using embedded EGM96 1-degree
      * geoid conversion and explicit terrain lookup options.
      */
-    ellipsoidalHeightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): EllipsoidalHeightM;
+    ellipsoidalHeightMWithOptions(longitude_deg: number, latitude_deg: number, options?: TerrainLookupOptions | null): EllipsoidalHeightM;
     /**
      * Parse terrain store bytes from a `Uint8Array`.
      */
@@ -3539,7 +4096,7 @@ export class MmapTerrain {
      * `{ longitudeDeg, latitudeDeg }` objects. Each entry is
      * `{ ok: true, heightM }` or `{ ok: false, error }`.
      */
-    heightBatch(points: any, options: any): any;
+    heightBatch(points: TerrainPoint[], options?: TerrainLookupOptions | null): TerrainHeightBatchResult[];
     /**
      * Terrain height in ORTHOMETRIC metres at `(longitudeDeg, latitudeDeg)`.
      *
@@ -3553,14 +4110,14 @@ export class MmapTerrain {
      * `options.interpolation` is `"bilinear"`, `"nearest"`, or
      * `"nearestPosting"`.
      */
-    heightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): number;
+    heightMWithOptions(longitude_deg: number, latitude_deg: number, options?: TerrainLookupOptions | null): number;
     /**
      * Batch typed ORTHOMETRIC terrain heights for longitude-first points.
      *
      * Each entry is `{ ok: true, orthometricHeightM: { valueM } }` or
      * `{ ok: false, error }`.
      */
-    orthometricHeightBatch(points: any, options: any): any;
+    orthometricHeightBatch(points: TerrainPoint[], options?: TerrainLookupOptions | null): TerrainOrthometricBatchResult[];
     /**
      * Typed ORTHOMETRIC terrain height `H` at `(longitudeDeg, latitudeDeg)`.
      */
@@ -3569,7 +4126,7 @@ export class MmapTerrain {
      * Typed ORTHOMETRIC terrain height `H` at `(longitudeDeg, latitudeDeg)`
      * with explicit lookup options.
      */
-    orthometricHeightMWithOptions(longitude_deg: number, latitude_deg: number, options: any): OrthometricHeightM;
+    orthometricHeightMWithOptions(longitude_deg: number, latitude_deg: number, options?: TerrainLookupOptions | null): OrthometricHeightM;
     /**
      * Parsed tile index records in store order.
      */
@@ -3748,7 +4305,7 @@ export class NmeaParseResult {
     [Symbol.dispose](): void;
     readonly diagnostics: any;
     readonly epochCount: number;
-    readonly epochs: any;
+    readonly epochs: FusionRtsEpoch[];
     readonly sentenceCount: number;
     readonly sentences: any;
 }
@@ -3762,7 +4319,7 @@ export class NtripClientMachine {
     connectionRequest(): Uint8Array;
     finish(): any;
     ggaMessage(now_s: number, position: any, utc_seconds_of_day: number): any;
-    constructor(config: any);
+    constructor(config: FusionConfig);
     push(bytes: Uint8Array): any;
     reset(): void;
     readonly state: NtripState;
@@ -4919,11 +5476,11 @@ export class PppFixedSolution {
     /**
      * Fixed ambiguities, integer cycles, as an id-keyed object.
      */
-    readonly fixedAmbiguitiesCycles: any;
+    readonly fixedAmbiguitiesCycles: Record<string, number>;
     /**
      * Fixed ambiguities, metres, as an id-keyed object.
      */
-    readonly fixedAmbiguitiesM: any;
+    readonly fixedAmbiguitiesM: PppScalarMap;
     /**
      * The float solution that seeded the integer search.
      */
@@ -4965,11 +5522,11 @@ export class PppFixedSolution {
     /**
      * Residual ionosphere states, metres, as an id-keyed object.
      */
-    readonly residualIonosphereM: any;
+    readonly residualIonosphereM: PppScalarMap;
     /**
      * Post-fit PPP residual rows.
      */
-    readonly residuals: any;
+    readonly residuals: PppResidual[];
     /**
      * Static PPP termination status.
      */
@@ -4977,7 +5534,7 @@ export class PppFixedSolution {
     /**
      * Temporal-correlation summary used by the conservative covariance.
      */
-    readonly temporalCorrelation: any;
+    readonly temporalCorrelation: PppTemporalCorrelation;
     /**
      * Temporal-correlation-deflated ECEF covariance, row-major 3-by-3.
      */
@@ -5020,7 +5577,7 @@ export class PppFloatSolution {
     /**
      * Float ambiguities, metres, as an id-keyed object.
      */
-    readonly ambiguitiesM: any;
+    readonly ambiguitiesM: PppScalarMap;
     readonly codeRmsM: number;
     readonly converged: boolean;
     /**
@@ -5058,11 +5615,11 @@ export class PppFloatSolution {
     /**
      * Residual ionosphere states, metres, as an id-keyed object.
      */
-    readonly residualIonosphereM: any;
+    readonly residualIonosphereM: PppScalarMap;
     /**
      * Post-fit PPP residual rows.
      */
-    readonly residuals: any;
+    readonly residuals: PppResidual[];
     /**
      * Static PPP termination status.
      */
@@ -5070,7 +5627,7 @@ export class PppFloatSolution {
     /**
      * Temporal-correlation summary used by the conservative covariance.
      */
-    readonly temporalCorrelation: any;
+    readonly temporalCorrelation: PppTemporalCorrelation;
     /**
      * Temporal-correlation-deflated ECEF covariance, row-major 3-by-3.
      */
@@ -5706,6 +6263,35 @@ export class RinexObsRepair {
     readonly repairedText: string;
 }
 
+/**
+ * Per-epoch results returned by `solveSppFromRinexObs`.
+ */
+export class RinexSppSolutionBatch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Original RINEX OBS epoch index for assembled batch item `index`.
+     */
+    epochIndex(index: number): number;
+    /**
+     * The solve error for assembled batch item `index`, or `undefined`.
+     */
+    error(index: number): string | undefined;
+    /**
+     * Whether assembled batch item `index` converged to a solution.
+     */
+    isOk(index: number): boolean;
+    /**
+     * The SPP solution for assembled batch item `index`.
+     */
+    solution(index: number): SppSolution;
+    /**
+     * Number of assembled RINEX epochs in the batch.
+     */
+    readonly count: number;
+}
+
 /**
  * Stateful MSM lock-time tracker for deriving RINEX LLI continuity bits.
  */
@@ -5778,7 +6364,7 @@ export class RtkFloatSolution {
     /**
      * Float single-difference ambiguities, metres, as an id-keyed object.
      */
-    readonly ambiguitiesM: any;
+    readonly ambiguitiesM: PppScalarMap;
     /**
      * Baseline (rover minus base) as a `Float64Array` `[dx, dy, dz]`, metres.
      */
@@ -6124,11 +6710,11 @@ export class SignalAnalysisModulation {
     /**
      * Published lower bound for DLL code-delay jitter.
      */
-    dllLowerBound(options: any): any;
+    dllLowerBound(options: DllJitterOptions): DllJitterResult;
     /**
      * Early-late DLL thermal-noise jitter for this modulation.
      */
-    dllThermalNoiseJitter(options: any, processing: DllProcessing): any;
+    dllThermalNoiseJitter(options: DllJitterOptions, processing: DllProcessing): DllJitterResult;
     /**
      * Fraction of total signal power inside a two-sided receiver bandwidth.
      */
@@ -6140,7 +6726,7 @@ export class SignalAnalysisModulation {
     /**
      * One-path early-late multipath error envelope on a delay grid.
      */
-    multipathErrorEnvelope(options: any, delay_chips: Float64Array): any;
+    multipathErrorEnvelope(options: MultipathEnvelopeOptions, delay_chips: Float64Array): MultipathEnvelopeResult;
     /**
      * Signal power inside a two-sided receiver bandwidth.
      */
@@ -6283,7 +6869,7 @@ export class SmoothedFusionTrajectory {
     /**
      * Smoothed epochs in the same order as the recorded history.
      */
-    readonly epochs: any;
+    readonly epochs: FusionRtsEpoch[];
 }
 
 export class SmoothedTrack {
@@ -6291,7 +6877,7 @@ export class SmoothedTrack {
     free(): void;
     [Symbol.dispose](): void;
     readonly epochCount: number;
-    readonly epochs: any;
+    readonly epochs: FusionRtsEpoch[];
 }
 
 /**
@@ -6384,7 +6970,7 @@ export class Sp3 {
      * is exhausted. Returns the surviving solution and the excluded satellites;
      * throws an `Error` if the fault is unresolved.
      */
-    fde(request: any): FdeSolution;
+    fde(request: FdeRequest): FdeSolution;
     /**
      * Interpolate `satellite`'s position and clock at each query epoch.
      *
@@ -6434,7 +7020,7 @@ export class Sp3 {
      * `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;
+    solveSpp(request: SppRequest): SppSolution;
     /**
      * Solve a batch of independent SPP epochs against this ephemeris in one call.
      *
@@ -6444,7 +7030,7 @@ export class Sp3 {
      * results are index-aligned to `epochs`; each epoch independently converged
      * or failed. Delegates to the serial reference batch kernel.
      */
-    solveSppBatch(epochs: any, options: any): SppBatchSolution;
+    solveSppBatch(epochs: SppRequest[], options?: SppBatchOptions | null): SppBatchSolution;
     /**
      * Run SPP and attach a Doppler velocity/clock-drift solve when Doppler rows solve.
      *
@@ -6467,7 +7053,7 @@ export class Sp3 {
      * `request` is the FDE request with a `robust` object. The implementation
      * delegates to `sidereon_core::quality::spp_robust_fde_driver`.
      */
-    sppRobustFdeDriver(request: any): FdeSolution;
+    sppRobustFdeDriver(request: FdeRequest): FdeSolution;
     /**
      * The exact parsed state of `satellite` at record `epochIndex` (no
      * interpolation). Throws a `RangeError` past the last epoch and a
@@ -7229,7 +7815,7 @@ export class StaticSolution {
     /**
      * Post-fit residuals as `{ epochIndex, satelliteId, residualM, ... }[]`.
      */
-    readonly residuals: any;
+    readonly residuals: PppResidual[];
     /**
      * Full state covariance, flat row-major square matrix in square metres.
      */
@@ -7931,7 +8517,7 @@ export class TrackFilterConfig {
     /**
      * Build a no-IMU track filter config from a JS object.
      */
-    constructor(config: any);
+    constructor(config: FusionConfig);
     toObject(): any;
     readonly dimension: number;
     readonly frame: string;
@@ -7943,7 +8529,7 @@ export class TrackRtsHistory {
     free(): void;
     [Symbol.dispose](): void;
     readonly epochCount: number;
-    readonly epochs: any;
+    readonly epochs: FusionRtsEpoch[];
 }
 
 export class TrackRtsHistoryBuilder {
@@ -8235,7 +8821,7 @@ export function angularSeparationCoords(a_lon_deg: number, a_lat_deg: number, b_
  * `araimLpv200Allocation()`. Returned `hplM`, `vplM`, `sigmaAccHM`,
  * `sigmaAccVM`, `emtM`, and per-mode ENU arrays are meters.
  */
-export function araim(geometry: any, ism: any, allocation: any): any;
+export function araim(geometry: AraimGeometry, ism: AraimIsm, allocation?: AraimAllocation | null): AraimResult;
 
 /**
  * Enumerate ARAIM fault hypotheses for the given geometry, ISM, and allocation.
@@ -8244,7 +8830,7 @@ export function araim(geometry: any, ism: any, allocation: any): any;
  * satellites are string tokens such as `"G01"`, and excluded constellations are
  * labels such as `"GPS"`.
  */
-export function araimFaultModes(geometry: any, ism: any, allocation: any): any;
+export function araimFaultModes(geometry: AraimGeometry, ism: AraimIsm, allocation?: AraimAllocation | null): AraimFaultHypothesis[];
 
 /**
  * LPV-200 ARAIM integrity and continuity allocation.
@@ -8253,7 +8839,7 @@ export function araimFaultModes(geometry: any, ism: any, allocation: any): any;
  * dimensionless, `pEmt` defaults to `1e-5`, and `maxFaultOrder` is an integer
  * fault order.
  */
-export function araimLpv200Allocation(): any;
+export function araimLpv200Allocation(): AraimAllocation;
 
 /**
  * Evaluate NRLMSISE-00 neutral-atmosphere density and temperature.
@@ -8274,6 +8860,11 @@ export function atmosphereDensity(lat_deg: number, lon_deg: number, alt_km: numb
  */
 export function atmosphereSpaceWeatherDefaults(): SpaceWeatherDefaults;
 
+/**
+ * Circular autocorrelation over all lags for a bipolar code vector.
+ */
+export function autocorrelation(code: Int8Array): Int32Array;
+
 /**
  * Solar beta angle in degrees from orbit normal and Sun vectors.
  */
@@ -8305,7 +8896,7 @@ export function boundedIlsSearch(float_cycles: Float64Array, covariance: any, ra
  * Defaults build the GPS `C1C`/`L1C` plus `C2W`/`L2W` arc used by the real
  * WTZR/WTZZ fixtures.
  */
-export function buildDualFrequencyRinexRtkArc(ephemeris: Sp3, base_obs: RinexObs, rover_obs: RinexObs, options?: any | null): any;
+export function buildDualFrequencyRinexRtkArc(ephemeris: Sp3, base_obs: RinexObs, rover_obs: RinexObs, options?: RtkRinexDualArcOptions | null): { epochs: RtkDualFrequencyArcEpoch[] };
 
 /**
  * Build single-frequency RTK arc records from parsed RINEX OBS products.
@@ -8315,7 +8906,7 @@ export function buildDualFrequencyRinexRtkArc(ephemeris: Sp3, base_obs: RinexObs
  * `{ signalPairs, maxEpochs, minCommonSatellites, includePredictionTime }`.
  * Defaults build the GPS `C1C`/`L1C` arc used by the real WTZR/WTZZ fixtures.
  */
-export function buildRinexRtkArc(ephemeris: Sp3, base_obs: RinexObs, rover_obs: RinexObs, options?: any | null): any;
+export function buildRinexRtkArc(ephemeris: Sp3, base_obs: RinexObs, rover_obs: RinexObs, options?: RtkRinexArcOptions | null): { epochs: RtkArcEpoch[]; wavelengthsM: Record<string, number>; offsetsM: Record<string, number> };
 
 /**
  * One wrapping GPS C/A chip at a zero-based index.
@@ -8442,6 +9033,19 @@ export function computeAllanDeviations(input: any): any;
  */
 export function correlate(iq: Float64Array, prn: bigint, options: any): CorrelationResult;
 
+/**
+ * Coherently correlate interleaved IQ samples against an explicit bipolar code.
+ *
+ * `iq` is `[i0, q0, i1, q1, ...]`. The coherent sum follows the core
+ * `zip(iq, code)` semantics and therefore uses the shorter non-empty input.
+ */
+export function correlateAgainst(iq: Float64Array, code: Int8Array, sample_rate_hz: number, doppler_hz: number): CorrelationResult;
+
+/**
+ * Single-lag circular correlation for two equal-length bipolar codes.
+ */
+export function correlationAt(code_a: Int8Array, code_b: Int8Array, lag: bigint): number;
+
 /**
  * Fitted parameter covariance from a converged solve, scaling `(J^T J)^-1` by
  * the post-fit reduced chi-square `s_sq = 2 * cost / (m - n)` (the same scale
@@ -8476,6 +9080,11 @@ export function covarianceIsSymmetric(covariance_km2: Float64Array): boolean;
  */
 export function coverageLookAngles(satellites: Tle[], stations: GroundStation[], epoch_unix_us: bigint): CoverageGrid;
 
+/**
+ * Circular cross-correlation over all lags for two equal-length bipolar codes.
+ */
+export function crossCorrelation(code_a: Int8Array, code_b: Int8Array): Int32Array;
+
 export function cwPropagate(rel: any, n_rad_s: number, dt_s: number): any;
 
 export function cwStm(n_rad_s: number, dt_s: number): Float64Array;
@@ -8995,7 +9604,7 @@ export function fitTrajectory(series: any, model: any, options: any): any;
  * `RtkWideLaneArcConfig` object. Delegates to
  * `sidereon_core::rtk_filter::arc::fix_wide_lane_rtk_arc`.
  */
-export function fixWideLaneRtkArc(epochs: any, config: any): any;
+export function fixWideLaneRtkArc(epochs: RtkDualFrequencyArcEpoch[], config: RtkWideLaneArcConfig): RtkWideLaneFixedResult;
 
 /**
  * J2 oblateness gravitational acceleration in km/s^2.
@@ -10273,7 +10882,7 @@ export function predictBatchSp3(sp3: Sp3, satellites: string[], receivers_ecef_m
  * `RtkIonosphereFreeArcConfig` object. Delegates to
  * `sidereon_core::rtk_filter::arc::prepare_ionosphere_free_rtk_arc`.
  */
-export function prepareIonosphereFreeRtkArc(epochs: any, wide_lane_cycles: any, config: any): any;
+export function prepareIonosphereFreeRtkArc(epochs: RtkDualFrequencyArcEpoch[], wide_lane_cycles: Record<string, number>, config: RtkIonosphereFreeArcConfig): RtkIonosphereFreeArcResult;
 
 /**
  * Propagate a fleet of already-initialized [`Tle`]s over a shared epoch grid in
@@ -10332,7 +10941,7 @@ export function pseudorangeVariance(elevation_deg: number, options: any): number
  * normalized residual satellite, reduced chi-square, normalized residual map,
  * RMS residual, and degrees of freedom.
  */
-export function raim(input: any, options: any): any;
+export function raim(input: RaimInput, options?: RaimOptions | null): RaimResult;
 
 /**
  * Run standalone range RAIM/FDE over a linearized measurement set.
@@ -10347,7 +10956,16 @@ export function raim(input: any, options: any): any;
  * Malformed input throws a `TypeError`; a rank-deficient or rejected set throws
  * an `Error`.
  */
-export function raimFdeDesign(rows: any, options: any): any;
+export function raimFdeDesign(rows: RangeFdeRow[], options?: RangeFdeOptions | null): RangeFdeResult;
+
+/**
+ * Run residual chi-square RAIM directly over an existing SPP solution.
+ *
+ * `solution` is a `SppSolution` from `solveSpp`, `solveBroadcast`, fallback,
+ * or a RINEX OBS convenience result. `options` is the same `RaimOptions` object
+ * accepted by `raim`; omit it for the core defaults.
+ */
+export function raimForSolution(solution: SppSolution, options?: RaimOptions | null): RaimResult;
 
 /**
  * Convert a pseudorange rate in metres per second to Doppler shift in hertz.
@@ -10731,7 +11349,7 @@ export function solveMovingBaseline(config: any): MovingBaselineSolution[];
  * `sidereon_core::precise_positioning::auto_init::solve_ppp_auto_init_fixed`.
  * Throws a `TypeError` for malformed input and an `Error` if the solve fails.
  */
-export function solvePppAutoInitFixed(sp3: Sp3, epochs: any, options: any, float_config: any, fixed_config: any): PppFixedSolution;
+export function solvePppAutoInitFixed(sp3: Sp3, epochs: PppEpoch[], options: PppAutoInitOptions | null | undefined, float_config: PppFloatConfig, fixed_config: PppFixedConfig): PppFixedSolution;
 
 /**
  * Solve a static multi-epoch float PPP arc from raw epochs, auto-initializing
@@ -10745,7 +11363,7 @@ export function solvePppAutoInitFixed(sp3: Sp3, epochs: any, options: any, float
  * `sidereon_core::precise_positioning::auto_init::solve_ppp_auto_init_float`.
  * Throws a `TypeError` for malformed input and an `Error` if the solve fails.
  */
-export function solvePppAutoInitFloat(sp3: Sp3, epochs: any, options: any, config: any): PppFloatSolution;
+export function solvePppAutoInitFloat(sp3: Sp3, epochs: PppEpoch[], options: PppAutoInitOptions | null | undefined, config: PppFloatConfig): PppFloatSolution;
 
 /**
  * Search integer ambiguities from a float PPP solution and re-solve fixed.
@@ -10754,7 +11372,7 @@ export function solvePppAutoInitFloat(sp3: Sp3, epochs: any, options: any, confi
  * `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;
+export function solvePppFixed(sp3: Sp3, epochs: PppEpoch[], float_solution: PppFloatSolution, config: PppFixedConfig): PppFixedSolution;
 
 /**
  * Solve a static multi-epoch float PPP arc against an SP3 product.
@@ -10763,7 +11381,7 @@ export function solvePppFixed(sp3: Sp3, epochs: any, float_solution: PppFloatSol
  * `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;
+export function solvePppFloat(sp3: Sp3, epochs: PppEpoch[], initial_state: PppFloatState, config: PppFloatConfig): PppFloatSolution;
 
 /**
  * Solve a sequential RTK baseline arc from raw rover+base epochs.
@@ -10775,7 +11393,7 @@ export function solvePppFloat(sp3: Sp3, epochs: any, initial_state: any, config:
  * filter state. Delegates to `sidereon_core::rtk_filter::arc::solve_rtk_arc`.
  * Throws a `TypeError` for malformed input and an `Error` if the solve fails.
  */
-export function solveRtkArc(epochs: any, config: any): any;
+export function solveRtkArc(epochs: RtkArcEpoch[], config: RtkArcConfig): RtkArcSolution;
 
 /**
  * Solve a static fixed RTK baseline with residual validation / FDE.
@@ -10793,6 +11411,15 @@ export function solveRtkFixed(config: any): RtkFixedSolution;
  */
 export function solveRtkFloat(config: any): RtkFloatSolution;
 
+/**
+ * Solve parsed RINEX OBS epochs serially against a broadcast ephemeris store.
+ *
+ * `rinexOptions` controls observation assembly; `solveOptions` accepts
+ * `withGeodetic`, `maxPdop`, and `coarseSearchSeeds`. The returned batch keeps
+ * per-epoch solve failures, so use `isOk(index)` before `solution(index)`.
+ */
+export function solveSppFromRinexObs(source: BroadcastEphemeris, obs: RinexObs, rinex_options?: RinexSppOptions | null, solve_options?: RinexSppSolveOptions | null): RinexSppSolutionBatch;
+
 /**
  * Solve SPP using an SBAS-corrected broadcast source and optional SBAS iono.
  *
@@ -10830,7 +11457,7 @@ export function solveStaticRinexRtkBaseline(ephemeris: Sp3, base_obs: RinexObs,
  * `RtkStaticArcConfig` object. Delegates to
  * `sidereon_core::rtk_filter::arc::solve_static_rtk_arc`.
  */
-export function solveStaticRtkArc(epochs: any, config: any): any;
+export function solveStaticRtkArc(epochs: RtkArcEpoch[], config: RtkStaticArcConfig): RtkStaticArcSolution;
 
 /**
  * Solve receiver velocity over an SP3 precise product. See
@@ -10929,6 +11556,15 @@ export function sphericalRadiusAt(covariance_enu_m2: any, probability: number):
  */
 export function splitJdToJ2000Seconds(jd_whole: number, jd_fraction: number): number;
 
+/**
+ * Assemble parsed RINEX OBS epochs into broadcast-backed SPP solve inputs.
+ *
+ * `source` is a parsed RINEX NAV broadcast store. `options` accepts
+ * `signalPolicy`, `corrections`, `initialGuess`, `satellites`, `met`, and
+ * `robust`; omit it for the core default policy for the observation file.
+ */
+export function sppInputsFromRinexObs(source: BroadcastEphemeris, obs: RinexObs, options?: RinexSppOptions | null): RinexSppEpochInputs[];
+
 export function ssrCorrectedState(broadcast: BroadcastEphemeris, store: SsrCorrectionStore, sat: string, t_j2000_s: number, fallback_to_broadcast?: boolean | null, allow_regional_provider?: number | null): any;
 
 /**