@neilberkman/sidereon 0.13.0 → 0.15.0

package/pkg-node/sidereon.d.ts

@@ -59,6 +59,34 @@ export class AcquisitionResult {
     readonly peakPower: number;
 }
 
+/**
+ * Airborne receiver and multipath contribution model.
+ */
+export class AirborneModel {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * AAD-A airborne model.
+     */
+    static aadA(): AirborneModel;
+    /**
+     * Default airborne model.
+     */
+    static defaultModel(): AirborneModel;
+    /**
+     * Construct an airborne model from a receiver noise term in metres.
+     */
+    constructor(sigma_noise_divergence_m: number);
+    /**
+     * Airborne receiver, divergence, and multipath sigma, metres, or `null`.
+     */
+    sigmaAirM(elevation_rad: number): any;
+    /**
+     * Receiver noise and code-carrier divergence sigma, metres.
+     */
+    readonly sigmaNoiseDivergenceM: number;
+}
+
 /**
  * A receiver or satellite ANTEX antenna calibration block.
  */
@@ -1221,6 +1249,61 @@ export class CoverageGrid {
     readonly stationCount: number;
 }
 
+/**
+ * SBAS degradation terms used when deriving an error model from a store.
+ */
+export class DegradationParams {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Default degradation parameters.
+     */
+    static defaultParams(): DegradationParams;
+    /**
+     * True when all degradation parameters are inside the valid domain.
+     */
+    isValid(): boolean;
+    /**
+     * Construct SBAS degradation parameters.
+     *
+     * Omitted numeric fields use the no-degradation defaults. Invalid values
+     * throw a `RangeError`.
+     */
+    constructor(delta_udre?: number | null, eps_fc_m?: number | null, eps_rrc_m?: number | null, eps_ltc_m?: number | null, eps_er_m?: number | null, eps_iono_m?: number | null, rss_udre?: boolean | null);
+    /**
+     * No extra degradation and no UDRE inflation.
+     */
+    static none(): DegradationParams;
+    /**
+     * Variance multiplier applied to the UDRE variance table.
+     */
+    readonly deltaUdre: number;
+    /**
+     * En-route degradation term, metres.
+     */
+    readonly epsErM: number;
+    /**
+     * Fast-correction degradation term, metres.
+     */
+    readonly epsFcM: number;
+    /**
+     * Ionospheric degradation term added to UIRE, metres.
+     */
+    readonly epsIonoM: number;
+    /**
+     * Long-term-correction degradation term, metres.
+     */
+    readonly epsLtcM: number;
+    /**
+     * Range-rate-correction degradation term, metres.
+     */
+    readonly epsRrcM: number;
+    /**
+     * Whether UDRE degradation terms are combined by root-sum-square.
+     */
+    readonly rssUdre: boolean;
+}
+
 /**
  * A DGNSS rover solve: the corrected SPP solution plus the base-relative
  * baseline.
@@ -1619,6 +1702,27 @@ export class Ephemeris {
     readonly velocityKmS: Float64Array;
 }
 
+/**
+ * A horizontal one-sigma error ellipse.
+ */
+export class ErrorEllipse {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Semi-major-axis orientation in radians, from east toward north.
+     */
+    readonly orientationRad: number;
+    /**
+     * Semi-major axis length, metres.
+     */
+    readonly semiMajorM: number;
+    /**
+     * Semi-minor axis length, metres.
+     */
+    readonly semiMinorM: number;
+}
+
 /**
  * A confidence ellipse from a 2x2 covariance block: semi-axes scaled by the
  * two-degree-of-freedom chi-square quantile `-2 ln(1 - confidence)`.
@@ -1864,6 +1968,43 @@ export class GeoidGrid {
     undulationsRad(points_rad: Float64Array): Float64Array;
 }
 
+/**
+ * Geometry observability and covariance-validation diagnostics.
+ */
+export class GeometryQuality {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Singular-value condition number of the design matrix.
+     */
+    readonly conditionNumber: number;
+    /**
+     * Whether residuals or a propagated prior validated the covariance bound.
+     */
+    readonly covarianceValidated: boolean;
+    /**
+     * Geometric dilution of precision for the solved state.
+     */
+    readonly gdop: number;
+    /**
+     * Whether residual-based RAIM can test the solve.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Rank of the design matrix used by the solve.
+     */
+    readonly rank: number;
+    /**
+     * Observation redundancy, `nObs - nParams`.
+     */
+    readonly redundancy: number;
+    /**
+     * Observability and validation tier.
+     */
+    readonly tier: ObservabilityTier;
+}
+
 /**
  * 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.
@@ -3276,6 +3417,34 @@ export class ObsPhaseShift {
     readonly system: GnssSystem;
 }
 
+/**
+ * Observability and validation tier for an estimation design.
+ *
+ * `ZeroRedundancy` means the design is full rank but has no residual degrees of
+ * freedom, so snapshot-solve covariance bounds are unvalidated unless a
+ * propagated prior is present. `Weak` means the design exceeded the configured
+ * condition-number or GDOP cutoff; the returned bounds are reported as computed
+ * and are not clamped.
+ */
+export enum ObservabilityTier {
+    /**
+     * At least one estimated parameter is not observable.
+     */
+    RankDeficient = 0,
+    /**
+     * Full rank with no residual degrees of freedom.
+     */
+    ZeroRedundancy = 1,
+    /**
+     * Full rank with residual degrees of freedom, but above a cutoff.
+     */
+    Weak = 2,
+    /**
+     * Full rank and within the configured cutoffs.
+     */
+    Nominal = 3,
+}
+
 /**
  * Optional observation-code allow-list for raw and carrier-phase rows. Build
  * with `new ObservationFilter()` then chain `.withSystem(system, codes)`.
@@ -4045,6 +4214,31 @@ export class ParsedTleFile {
     readonly skipped: number;
 }
 
+/**
+ * A percentile circle or sphere radius.
+ */
+export class PercentileRadius {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Approximate named radius, metres, when applicable.
+     */
+    readonly approxM: number;
+    /**
+     * Whether `approxM` is valid for the covariance ratio.
+     */
+    readonly approxValid: boolean;
+    /**
+     * Probability mass inside this radius.
+     */
+    readonly probability: number;
+    /**
+     * Exact circle or sphere radius, metres.
+     */
+    readonly radiusM: number;
+}
+
 /**
  * A long span represented by contiguous independently-fitted reduced-orbit
  * segments. Carries the fitted segments and the time scale they were fitted in;
@@ -4124,6 +4318,89 @@ export class PiecewiseOrbitSourceFit {
     readonly usedSamples: number;
 }
 
+/**
+ * Standard position-error metrics derived from a position covariance.
+ */
+export class PositionErrorMetrics {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Horizontal 50 percent circle radius.
+     */
+    readonly cepM: PercentileRadius;
+    /**
+     * Distance root mean square, metres.
+     */
+    readonly drmsM: number;
+    /**
+     * Horizontal one-sigma covariance ellipse.
+     */
+    readonly ellipse: ErrorEllipse;
+    /**
+     * Mean radial spherical error, metres.
+     */
+    readonly mrseM: number;
+    /**
+     * Horizontal 95 percent circle radius.
+     */
+    readonly r95M: PercentileRadius;
+    /**
+     * Horizontal 99 percent circle radius.
+     */
+    readonly r99M: PercentileRadius;
+    /**
+     * Three-dimensional 50 percent sphere radius.
+     */
+    readonly sepM: PercentileRadius;
+    /**
+     * East standard deviation, metres.
+     */
+    readonly sigmaEM: number;
+    /**
+     * North standard deviation, metres.
+     */
+    readonly sigmaNM: number;
+    /**
+     * Up standard deviation, metres.
+     */
+    readonly sigmaUM: number;
+    /**
+     * Two times distance root mean square, metres.
+     */
+    readonly twoDrmsM: number;
+    /**
+     * Vertical 50 percent one-dimensional radius, metres.
+     */
+    readonly vepM: number;
+}
+
+/**
+ * IEEE 1139 fractional-frequency PSD power-law noise type.
+ */
+export enum PowerLawNoiseType {
+    /**
+     * Random-walk frequency modulation, `S_y(f) = h_-2 f^-2`.
+     */
+    RandomWalkFM = 0,
+    /**
+     * Flicker frequency modulation, `S_y(f) = h_-1 f^-1`.
+     */
+    FlickerFM = 1,
+    /**
+     * White frequency modulation, `S_y(f) = h_0`.
+     */
+    WhiteFM = 2,
+    /**
+     * Flicker phase modulation, `S_y(f) = h_1 f`.
+     */
+    FlickerPM = 3,
+    /**
+     * White phase modulation, `S_y(f) = h_2 f^2`.
+     */
+    WhitePM = 4,
+}
+
 /**
  * Static integer-fixed PPP solution.
  */
@@ -4770,6 +5047,11 @@ export class RtkFixedSolution {
      * The underlying float baseline as a `Float64Array` `[dx, dy, dz]`, metres.
      */
     readonly floatBaselineM: Float64Array;
+    /**
+     * Geometry observability and covariance-validation diagnostics for the
+     * float design used by the integer-fixed solve.
+     */
+    readonly geometryQuality: GeometryQuality;
     readonly integerCandidates: number;
     /**
      * Integer ambiguity ratio, or `undefined` when no ratio was computed.
@@ -4779,6 +5061,16 @@ export class RtkFixedSolution {
      * Integer ambiguity-fix status: `"Fixed"` or `"NotFixed"`.
      */
     readonly integerStatus: string;
+    /**
+     * Whether residual-based RAIM can test the float design used by the
+     * integer-fixed solve.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Observation redundancy, `nObs - nParams`, for the float design used by
+     * the integer-fixed solve.
+     */
+    readonly redundancy: number;
 }
 
 /**
@@ -4798,9 +5090,24 @@ export class RtkFloatSolution {
     readonly baselineM: Float64Array;
     readonly codeRmsM: number;
     readonly converged: boolean;
+    /**
+     * Geometry observability and covariance-validation diagnostics for the
+     * final double-difference design. `ZeroRedundancy` bounds are unvalidated
+     * for snapshot solves, `Weak` bounds are unclamped, and rank-deficient
+     * designs are returned as a singular-geometry `Error`.
+     */
+    readonly geometryQuality: GeometryQuality;
     readonly iterations: number;
     readonly nObservations: number;
     readonly phaseRmsM: number;
+    /**
+     * Whether residual-based RAIM can test the float design.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Observation redundancy, `nObs - nParams`, for the float design.
+     */
+    readonly redundancy: number;
     readonly weightedRmsM: number;
 }
 
@@ -4928,6 +5235,170 @@ export class SbasCorrectionStore {
     setStalenessSeconds(seconds: number): void;
 }
 
+/**
+ * Index-aligned SBAS error model for protection-level geometry rows.
+ */
+export class SbasErrorModel {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Build an SBAS error model from a decoded correction store.
+     *
+     * `geo` is an SBAS satellite token, `geometry` is protection geometry, and
+     * `epochJ2000S` is the receive epoch used for freshness checks. Omit
+     * `airborne` or `degradation` to use their defaults.
+     */
+    static fromStore(store: SbasCorrectionStore, geo: string, geometry: any, airborne: AirborneModel | null | undefined, epoch_j2000_s: number, degradation?: DegradationParams | null): SbasErrorModel;
+    /**
+     * Construct an SBAS error model from rows.
+     *
+     * `rows` is an array of `{ id, sigmaFltM, sigmaUireM?, sigmaAirM?,
+     * sigmaTropoM? }` objects. As a shorthand, a row may provide only
+     * `{ id, sigmaM }`, which is stored as the total one-sigma range term.
+     */
+    constructor(rows: any);
+    /**
+     * Return the row for a satellite token, or `undefined` if it is absent.
+     */
+    rowFor(id: string): SbasSisError | undefined;
+    /**
+     * Number of range-error rows in the model.
+     */
+    readonly rowCount: number;
+    /**
+     * Error-model rows as plain objects.
+     */
+    readonly rows: any;
+}
+
+/**
+ * Fixed SBAS protection-level multipliers.
+ */
+export class SbasKMultipliers {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * En-route through non-precision-approach SBAS K multipliers.
+     */
+    static enRouteNpa(): SbasKMultipliers;
+    /**
+     * Construct SBAS horizontal and vertical K multipliers.
+     *
+     * Both values must be positive finite numbers.
+     */
+    constructor(k_h: number, k_v: number);
+    /**
+     * Precision-approach SBAS K multipliers.
+     */
+    static precisionApproach(): SbasKMultipliers;
+    /**
+     * Horizontal K multiplier.
+     */
+    readonly kH: number;
+    /**
+     * Vertical K multiplier.
+     */
+    readonly kV: number;
+}
+
+/**
+ * SBAS protection-level input or numerical failure.
+ */
+export enum SbasPlError {
+    /**
+     * The geometry lacks enough independent rows for the active clocks.
+     */
+    InsufficientGeometry = 0,
+    /**
+     * Matrix projection or covariance processing failed.
+     */
+    NumericalFailure = 1,
+    /**
+     * The supplied error model or K multipliers are outside their domain.
+     */
+    InvalidErrorModel = 2,
+}
+
+/**
+ * SBAS protection-level output for one geometry snapshot.
+ */
+export class SbasProtection {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * East one-sigma standard deviation, metres.
+     */
+    readonly dEastM: number;
+    /**
+     * East-north covariance term, square metres.
+     */
+    readonly dEnM2: number;
+    /**
+     * Horizontal one-sigma semi-major axis, metres.
+     */
+    readonly dMajorM: number;
+    /**
+     * North one-sigma standard deviation, metres.
+     */
+    readonly dNorthM: number;
+    /**
+     * Horizontal protection level, metres.
+     */
+    readonly hplM: number;
+    /**
+     * Vertical one-sigma standard deviation, metres.
+     */
+    readonly sigmaUM: number;
+    /**
+     * Vertical protection level, metres.
+     */
+    readonly vplM: number;
+}
+
+/**
+ * One satellite's SBAS one-sigma range-error budget.
+ */
+export class SbasSisError {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Construct one SBAS range-error row.
+     *
+     * Component sigmas are metres. They are combined by root-sum-square when
+     * the model is evaluated.
+     */
+    constructor(id: string, sigma_flt_m: number, sigma_uire_m: number, sigma_air_m: number, sigma_tropo_m: number);
+    /**
+     * Total one-sigma range error, metres, or `null` if invalid.
+     */
+    sigmaM(): any;
+    /**
+     * Sum-of-squares range variance, square metres, or `null` if invalid.
+     */
+    varianceM2(): any;
+    /**
+     * Satellite token for this range-error row.
+     */
+    readonly id: string;
+    /**
+     * Airborne receiver noise, divergence, and multipath sigma, metres.
+     */
+    readonly sigmaAirM: number;
+    /**
+     * Fast and long-term correction residual sigma, metres.
+     */
+    readonly sigmaFltM: number;
+    /**
+     * Tropospheric residual sigma, metres.
+     */
+    readonly sigmaTropoM: number;
+    /**
+     * User ionospheric range-error sigma, metres.
+     */
+    readonly sigmaUireM: number;
+}
+
 /**
  * Per-constellation single-frequency pseudorange code-selection policy. Build
  * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
@@ -5627,10 +6098,25 @@ export class SppSolution {
      * for geodetic output, otherwise `undefined`.
      */
     readonly geodetic: Float64Array | undefined;
+    /**
+     * Geometry observability and covariance-validation diagnostics for this
+     * solved design. `ZeroRedundancy` marks unvalidated snapshot covariance
+     * bounds, `Weak` leaves large bounds unclamped, and rank-deficient designs
+     * are returned as a singular-geometry `Error` rather than a solution.
+     */
+    readonly geometryQuality: GeometryQuality;
     /**
      * ECEF position as a `Float64Array` `[x, y, z]`, metres.
      */
     readonly positionM: Float64Array;
+    /**
+     * Whether residual-based RAIM can test the accepted solve.
+     */
+    readonly raimCheckable: boolean;
+    /**
+     * Degrees of freedom in the accepted solve: `usedCount - (3 + clocks)`.
+     */
+    readonly redundancy: number;
     /**
      * Post-fit residuals, metres, index-aligned to `usedSats`.
      */
@@ -6253,6 +6739,16 @@ export function acquire(samples: Float64Array, prn: bigint, options: any): Acqui
  */
 export function allanDeviation(series: any, tau0_s: number, averaging_factors: any): any;
 
+/**
+ * Exact ADEV log-log slope for a power-law noise type.
+ */
+export function allanDeviationPowerLawSlope(noise_type: PowerLawNoiseType): number;
+
+/**
+ * Exact Allan-variance tau exponent for a power-law noise type.
+ */
+export function allanVariancePowerLawTauExponent(noise_type: PowerLawNoiseType): number;
+
 /**
  * Alpha-beta measurement update applied to a predicted scalar state.
  *
@@ -6617,6 +7113,14 @@ export function defaultSppFrequencyHz(system: GnssSystem): number | undefined;
  */
 export function detectCycleSlips(arc: any, options: any): SlipResult[];
 
+/**
+ * Detect candidate displacement steps in a station position series.
+ *
+ * `options` may set `windowYears`, `scoreThreshold`, `minOffsetM`,
+ * `minSamplesEachSide`, `minSeparationYears`, and nested `midas` controls.
+ */
+export function detectSteps(series: any, options: any): any;
+
 /**
  * Apply base pseudorange corrections to rover observations by satellite token.
  *
@@ -6918,6 +7422,25 @@ export function fitPiecewiseReducedOrbitSp3(sp3: Sp3, satellite: string, options
  */
 export function fitPiecewiseReducedOrbitTle(tle: Tle, options: any): PiecewiseOrbitSourceFit;
 
+/**
+ * Identify power-law clock-noise regions from ADEV and MDEV curves.
+ *
+ * `adev` and `mdev` are `{ tauS, deviation, n }` objects, matching the output
+ * from the Allan-family functions. `options` may set `basicTauS`,
+ * `measurementBandwidthHz`, `minPointsPerOctave`, `slopeTolerance`, and
+ * `scatterTolerance`.
+ */
+export function fitPowerLawNoise(adev: any, mdev: any, options: any): any;
+
+/**
+ * Fit one satellite orbit from caller-supplied precise ephemeris samples.
+ *
+ * `samples` is the same array accepted by `preciseEphemerisSamplesFromSamples`:
+ * `{ sat, epoch, positionEcefM, clockS?, clockEvent? }` with epochs in seconds
+ * since J2000.
+ */
+export function fitPreciseEphemerisSampleOrbit(samples: any, satellite: string, options: any): any;
+
 /**
  * Fit a reduced-orbit model to ECEF position samples.
  *
@@ -6944,11 +7467,29 @@ export function fitReducedOrbitSp3(sp3: Sp3, satellite: string, options: any): R
  */
 export function fitReducedOrbitTle(tle: Tle, options: any): ReducedOrbitSourceFit;
 
+/**
+ * Fit one satellite orbit from a parsed SP3 precise product.
+ *
+ * `satellite` is an IGS token such as `"G01"`. `options` may set
+ * `forceModel`, `integrator`, `integratorOptions`, `solverOptions`,
+ * `linearSolve`, `minLedgerSamples`, and `drag`.
+ */
+export function fitSp3PreciseOrbit(sp3: Sp3, satellite: string, options: any): any;
+
 /**
  * Fit SGP4 mean elements and optional B* to TEME state samples.
  */
 export function fitTle(samples: any, config: any): TleFit;
 
+/**
+ * Fit a geodetic trajectory model with velocity, seasonal, and step terms.
+ *
+ * `model` may set `referenceEpochYear`, `includeAnnual`,
+ * `includeSemiannual`, and `offsetEpochsYear`. `options` may set `loss`,
+ * `fScaleM`, and `maxNfev`.
+ */
+export function fitTrajectory(series: any, model: any, options: any): any;
+
 /**
  * Fix Melbourne-Wubbena wide-lane ambiguities over a dual-frequency RTK arc.
  *
@@ -7580,6 +8121,26 @@ export function meridianTransits(body: string, station: any, start_unix_us: bigi
 
 export function meridianTransitsSpk(spk: Spk, body: string, station: any, start_unix_us: bigint, end_unix_us: bigint, step_s: number, tolerance_s: number): any;
 
+/**
+ * Rotate an ECEF covariance to ENU and compute position-error metrics.
+ *
+ * `receiver` is `{ latRad, lonRad, heightM? }` with radians and metres.
+ */
+export function metricsFromEcefCovarianceM2(covariance_ecef_m2: any, receiver: any): PositionErrorMetrics;
+
+/**
+ * Compute position-error metrics from an ENU covariance in square metres.
+ */
+export function metricsFromEnuCovarianceM2(covariance_enu_m2: any): PositionErrorMetrics;
+
+/**
+ * Compute position-error metrics from a kinematic solution object.
+ *
+ * The object must include `positionM` and `positionCovarianceM2`; optional
+ * extra kinematic fields are accepted and ignored by this metric calculation.
+ */
+export function metricsFromKinematicSolution(solution: any): PositionErrorMetrics;
+
 /**
  * Modified Allan deviation for explicit averaging factors.
  *
@@ -7589,6 +8150,11 @@ export function meridianTransitsSpk(spk: Spk, body: string, station: any, start_
  */
 export function modifiedAdev(series: any, tau0_s: number, averaging_factors: any): any;
 
+/**
+ * Exact MDEV log-log slope for a power-law noise type.
+ */
+export function modifiedAllanDeviationPowerLawSlope(noise_type: PowerLawNoiseType): number;
+
 /**
  * Mean, variance, skewness, and excess kurtosis of a residual set in one pass.
  *
@@ -7671,6 +8237,15 @@ export function nequickGDelayM(_eval: any, frequency_hz: number): number;
  */
 export function nequickGStecTecu(_eval: any): number;
 
+/**
+ * Estimate a station network velocity field in one local ENU frame.
+ *
+ * The input is `{ frame: { origin, removeCommonMode? }, stations }`. Each
+ * station has `{ id, reference, series }`, and each series follows
+ * `velocityMidas`.
+ */
+export function networkField(input: any): any;
+
 /**
  * Scalar normalized innovation squared statistic.
  */
@@ -7733,6 +8308,11 @@ export function normalizedInnovation(innovation: number, innovation_variance: nu
  */
 export function ntripRequestBytes(config: any): Uint8Array;
 
+/**
+ * Stable string label for an [`ObservabilityTier`] enum value.
+ */
+export function observabilityTierLabel(tier: ObservabilityTier): string;
+
 /**
  * Missing-position sentinel used in failed observable-state batch elements.
  *
@@ -7793,6 +8373,14 @@ export function observeSpkBody(station: any, epoch_unix_us: bigint, spk: Spk, na
  */
 export function oceanTideLoading(station_ecef_m: Float64Array, year: number, month: number, day: number, fractional_hour: number, amplitude_m: Float64Array, phase_deg: Float64Array): Float64Array;
 
+/**
+ * Broadcast-derived per-satellite orbit-repeat lag, in seconds.
+ *
+ * `satellite` is an IGS token such as `"G01"`, and `nearEpochJ2000S` is the
+ * broadcast-selection epoch in seconds since J2000.
+ */
+export function orbitRepeatLag(ephemeris: BroadcastEphemeris, satellite: string, near_epoch_j2000_s: number): number;
+
 /**
  * Orthometric height `H = h - N` (metres above mean sea level) from an
  * ellipsoidal height and a geodetic position in radians, using the built-in
@@ -7955,6 +8543,14 @@ export function parseSpaceWeatherTxt(text: string): SpaceWeatherTable;
  */
 export function parseTleFile(text: string, ops_mode_label?: string | null): ParsedTleFile;
 
+/**
+ * Score repeating components at candidate periods.
+ *
+ * `series` and `candidatePeriodsS` are JS number arrays. `sampleIntervalS`
+ * defaults to one second. The result is an array of `{ periodS, strength }`.
+ */
+export function periodicityStrength(series: any, candidate_periods_s: any, sample_interval_s?: number | null): any;
+
 /**
  * Sun-satellite-observer phase angle in degrees.
  */
@@ -8066,7 +8662,7 @@ export function propagateKepler(coe: any, mu_km3_s2: number, dt_s: number): any;
  * epochs.
  *
  * `request` is a plain object; see the `PropagateStateRequest` TypeScript type.
- * Throws a `TypeError` for malformed input (wrong shape, unknown selector), a
+ * Throws a `TypeError` for malformed input (wrong layout, unknown selector), a
  * `RangeError` for a non-positive initial step, and an `Error` if the engine's
  * propagation fails.
  */
@@ -8103,6 +8699,25 @@ export function rangeRateToDoppler(range_rate_m_s: number, carrier_hz: number):
 
 export function relativeState(chief: any, deputy: any): any;
 
+/**
+ * Compute pre-data ARAIM reliability using an ARAIM ISM range-error model.
+ *
+ * `geometry` and `ism` use the same plain objects accepted by `araim`.
+ * `options` follows `reliabilityDesign`. External effects are returned in local
+ * east, north, up metres. Uncheckable rows return `null` for optional fields.
+ */
+export function reliabilityAraim(geometry: any, ism: any, options: any): any;
+
+/**
+ * Compute pre-data reliability from supplied range design rows.
+ *
+ * `rows` is an array of `{ id, designRow, sigmaM }` objects. `options` may set
+ * `{ alpha?, power?, beta?, lambda0Override?, lambda0?, minRedundancy? }`.
+ * `power` is converted to the core missed-detection probability. Rows below
+ * `minRedundancy` return `null` for `mdbM`, `externalEnuM`, and `biasToNoise`.
+ */
+export function reliabilityDesign(rows: any, options: any): any;
+
 /**
  * Repair RINEX navigation text.
  */
@@ -8113,6 +8728,11 @@ export function repairRinexNav(bytes: Uint8Array, options: any): RinexNavRepair;
  */
 export function repairRinexObs(bytes: Uint8Array, options: any): RinexObsRepair;
 
+/**
+ * Default ground-track repeat period for a GNSS constellation, in seconds.
+ */
+export function repeatPeriod(system: GnssSystem): number;
+
 /**
  * Build a sampled GPS C/A code replica, an `Int8Array`.
  */
@@ -8226,12 +8846,26 @@ export function satelliteVisualMagnitude(range_km: number, phase_angle_deg: numb
  */
 export function sbasCorrectedState(broadcast: BroadcastEphemeris, store: SbasCorrectionStore, geo: string, sat: string, t_j2000_s: number, mode?: string | null): any;
 
+/**
+ * Stable string label for an [`SbasPlError`] enum value.
+ */
+export function sbasPlErrorLabel(error: SbasPlError): string;
+
 /**
  * Convert an SBAS broadcast PRN number such as `129` to an SBAS satellite
  * token such as `"S29"`. Returns `null` when the PRN is outside the SBAS range.
  */
 export function sbasPrnToSat(broadcast_prn: number): any;
 
+/**
+ * Compute SBAS horizontal and vertical protection levels.
+ *
+ * `geometry` is the ARAIM protection geometry object with rows, receiver, and
+ * clock systems. `model` supplies one range-error row per satellite. `k`
+ * supplies the fixed SBAS multipliers.
+ */
+export function sbasProtectionLevels(geometry: any, model: SbasErrorModel, k: SbasKMultipliers): SbasProtection;
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -8303,6 +8937,15 @@ export function shadowFraction(satellite_position_km: Float64Array, sun_position
  */
 export function shapiroWilk(x: Float64Array): any;
 
+/**
+ * Apply a sidereal residual filter to a scalar series.
+ *
+ * `series` is a JS number array, `periodS` is seconds, and `options` may set
+ * `sampleIntervalS`, `priorPeriods`, `minCoverage`, and `templateMethod`.
+ * Returns `{ filtered, template, coverage, underCovered }`.
+ */
+export function siderealFilter(series: any, period_s: number, options: any): any;
+
 /**
  * Build satellite-keyed pseudorange sigmas in metres from `{ satelliteId,
  * elevationDeg, cn0Dbhz? }` entries. Invalid entries are dropped by the core.
@@ -8738,6 +9381,15 @@ export function validate(records: any): any;
  */
 export function validateAgainstSp3Ids(records: any, ids: any): any;
 
+/**
+ * Estimate robust station velocity with the MIDAS method.
+ *
+ * `series` is `{ samples, frame? }`, where samples are
+ * `{ epochYear, positionM, covarianceM2? }`. The frame is `"enu"` by default
+ * or `{ kind: "ecef", reference }`.
+ */
+export function velocityMidas(series: any, options: any): any;
+
 /**
  * Satellites visible above `minElevationDeg` from `station` at a single instant,
  * from already-initialized [`Tle`]s: the opsmode-preserving constellation
@@ -8786,3 +9438,12 @@ export function wideLaneWavelength(f1_hz: number, f2_hz: number): number;
  * Convert a DTED tile tree and write canonical terrain store bytes to a path.
  */
 export function writeDtedTreeToMmapStore(root: string, out_path: string): void;
+
+/**
+ * Compute Baarda's w-test noncentrality from false-alarm probability and power.
+ *
+ * `alpha` is the two-sided false-alarm probability. `power` is detection power,
+ * so the core missed-detection probability is `1 - power`. The returned object
+ * contains `delta0` and `lambda0 = delta0 * delta0`.
+ */
+export function wtestNoncentrality(alpha: number, power: number): any;