gnss-js 2.13.0 → 2.14.0

package/dist/analysis.cjs

@@ -25,9 +25,12 @@ __export(analysis_exports, {
   IonoAccumulator: () => IonoAccumulator,
   MultipathAccumulator: () => MultipathAccumulator,
   analyzeQuality: () => analyzeQuality,
+  applyHelmertFit: () => applyHelmertFit,
   applyIonoDcb: () => applyIonoDcb,
   computeIonoRate: () => computeIonoRate,
   detrendIonoArcs: () => detrendIonoArcs,
+  estimateHelmert: () => estimateHelmert,
+  fitCoordinateSeries: () => fitCoordinateSeries,
   parseSinexBiasDcb: () => parseSinexBiasDcb
 });
 module.exports = __toCommonJS(analysis_exports);
@@ -1924,6 +1927,525 @@ async function analyzeQuality(file, header, onProgress, signal) {
     iono: ionoAccum.finalize()
   };
 }
+
+// src/constants/wgs84.ts
+var WGS84_SEMI_MAJOR_AXIS = 6378137;
+var WGS84_FLATTENING = 1 / 298.257223563;
+var WGS84_ECCENTRICITY_SQUARED = 0.006694379990197;
+
+// src/coordinates/ecef.ts
+function ecefToGeodetic(x, y, z) {
+  const lon = Math.atan2(y, x);
+  const p = Math.sqrt(x * x + y * y);
+  if (p < 1e-10) {
+    const b = WGS84_SEMI_MAJOR_AXIS * Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED);
+    const lat2 = z >= 0 ? Math.PI / 2 : -Math.PI / 2;
+    const alt2 = Math.abs(z) - b;
+    return [lat2, lon, alt2];
+  }
+  let lat = Math.atan2(z, p * (1 - WGS84_ECCENTRICITY_SQUARED));
+  let N;
+  for (let i = 0; i < 10; i++) {
+    const sinLat2 = Math.sin(lat);
+    N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat2 * sinLat2);
+    const prevLat = lat;
+    lat = Math.atan2(z + WGS84_ECCENTRICITY_SQUARED * N * sinLat2, p);
+    if (Math.abs(lat - prevLat) < 1e-15) break;
+  }
+  const sinLat = Math.sin(lat);
+  N = WGS84_SEMI_MAJOR_AXIS / Math.sqrt(1 - WGS84_ECCENTRICITY_SQUARED * sinLat * sinLat);
+  const alt = p / Math.cos(lat) - N;
+  return [lat, lon, alt];
+}
+
+// src/analysis/noise-model.ts
+function cholesky(M, n) {
+  for (let j = 0; j < n; j++) {
+    let d = M[j * n + j];
+    for (let k = 0; k < j; k++) d -= M[j * n + k] ** 2;
+    if (d <= 0) return false;
+    d = Math.sqrt(d);
+    M[j * n + j] = d;
+    for (let i = j + 1; i < n; i++) {
+      let s = M[i * n + j];
+      for (let k = 0; k < j; k++) s -= M[i * n + k] * M[j * n + k];
+      M[i * n + j] = s / d;
+    }
+  }
+  return true;
+}
+function forward(L, n, b) {
+  for (let i = 0; i < n; i++) {
+    let s = b[i];
+    for (let k = 0; k < i; k++) s -= L[i * n + k] * b[k];
+    b[i] = s / L[i * n + i];
+  }
+}
+function flickerCovariance(idx) {
+  const N = idx[idx.length - 1] + 1;
+  const h = new Float64Array(N);
+  h[0] = 1;
+  for (let i = 1; i < N; i++) h[i] = h[i - 1] * (i - 1 + 0.5) / i;
+  const n = idx.length;
+  const F = new Float64Array(n * n);
+  for (let a = 0; a < n; a++)
+    for (let b = 0; b <= a; b++) {
+      const ia = idx[a];
+      const ib = idx[b];
+      let s = 0;
+      for (let k = 0; k <= ib; k++) s += h[ia - k] * h[ib - k];
+      F[a * n + b] = s;
+      F[b * n + a] = s;
+    }
+  let tr = 0;
+  for (let a = 0; a < n; a++) tr += F[a * n + a];
+  const scale = n / tr;
+  for (let i = 0; i < F.length; i++) F[i] *= scale;
+  return F;
+}
+var MAX_SAMPLES = 360;
+function fitWhiteFlicker(A, y, tYears) {
+  let rows = A.map((_, i) => i);
+  if (rows.length > MAX_SAMPLES) {
+    const step = rows.length / MAX_SAMPLES;
+    rows = Array.from({ length: MAX_SAMPLES }, (_, k) => Math.floor(k * step));
+  }
+  const n = rows.length;
+  const p = A[0]?.length ?? 0;
+  if (n < p + 5) return null;
+  const dts = rows.slice(1).map((r, k) => tYears[r] - tYears[rows[k]]).filter((d) => d > 0).sort((a, b) => a - b);
+  const dt = dts[dts.length >> 1] ?? 1 / 365.25;
+  const t0 = tYears[rows[0]];
+  const idx = rows.map((r) => Math.round((tYears[r] - t0) / dt));
+  for (let k = 1; k < n; k++)
+    if (idx[k] <= idx[k - 1]) idx[k] = idx[k - 1] + 1;
+  const F = flickerCovariance(idx);
+  const evaluate = (phi) => {
+    const C = new Float64Array(n * n);
+    for (let i = 0; i < n * n; i++) C[i] = phi * F[i];
+    for (let i = 0; i < n; i++) C[i * n + i] += 1 - phi;
+    if (!cholesky(C, n)) return null;
+    const Aw = Array.from({ length: p }, (_, j) => {
+      const col = Float64Array.from(rows, (r) => A[r][j]);
+      forward(C, n, col);
+      return col;
+    });
+    const yw = Float64Array.from(rows, (r) => y[r]);
+    forward(C, n, yw);
+    const N = Array.from(
+      { length: p },
+      (_, a) => Array.from({ length: p }, (_2, b) => {
+        let s = 0;
+        for (let i = 0; i < n; i++) s += Aw[a][i] * Aw[b][i];
+        return s;
+      })
+    );
+    const rhs = Array.from({ length: p }, (_, a) => {
+      let s = 0;
+      for (let i = 0; i < n; i++) s += Aw[a][i] * yw[i];
+      return s;
+    });
+    const Ninv = invert(N);
+    if (!Ninv) return null;
+    const beta = Ninv.map((row) => row.reduce((s, v, k) => s + v * rhs[k], 0));
+    let rss = 0;
+    for (let i = 0; i < n; i++) {
+      let m = 0;
+      for (let j = 0; j < p; j++) m += Aw[j][i] * beta[j];
+      rss += (yw[i] - m) ** 2;
+    }
+    const sigma2 = rss / n;
+    let logdet = 0;
+    for (let i = 0; i < n; i++) logdet += 2 * Math.log(C[i * n + i]);
+    const logL = -0.5 * (n * Math.log(sigma2) + logdet + n);
+    return {
+      logL,
+      velocity: beta[1],
+      velocitySigma: Math.sqrt(sigma2 * Ninv[1][1])
+    };
+  };
+  let best = null;
+  for (let k = 0; k <= 20; k++) {
+    const phi = Math.min(k / 20, 0.995);
+    const r = evaluate(phi);
+    if (r && (!best || r.logL > best.r.logL)) best = { phi, r };
+  }
+  if (!best) return null;
+  let lo = Math.max(0, best.phi - 0.05);
+  let hi = Math.min(0.995, best.phi + 0.05);
+  const g = (Math.sqrt(5) - 1) / 2;
+  for (let it = 0; it < 12; it++) {
+    const a = hi - g * (hi - lo);
+    const b = lo + g * (hi - lo);
+    const ra = evaluate(a);
+    const rb = evaluate(b);
+    if (!ra || !rb) break;
+    if (ra.logL > rb.logL) {
+      hi = b;
+      if (ra.logL > best.r.logL) best = { phi: a, r: ra };
+    } else {
+      lo = a;
+      if (rb.logL > best.r.logL) best = { phi: b, r: rb };
+    }
+  }
+  return {
+    flickerShare: best.phi,
+    velocitySigma: best.r.velocitySigma,
+    velocity: best.r.velocity
+  };
+}
+function invert(N) {
+  const p = N.length;
+  const M = N.map((row, i) => [
+    ...row,
+    ...Array.from({ length: p }, (_, j) => i === j ? 1 : 0)
+  ]);
+  for (let c = 0; c < p; c++) {
+    let piv = c;
+    for (let r = c + 1; r < p; r++)
+      if (Math.abs(M[r][c]) > Math.abs(M[piv][c])) piv = r;
+    if (Math.abs(M[piv][c]) < 1e-14) return null;
+    [M[c], M[piv]] = [M[piv], M[c]];
+    const d = M[c][c];
+    for (let k = 0; k < 2 * p; k++) M[c][k] /= d;
+    for (let r = 0; r < p; r++) {
+      if (r === c) continue;
+      const f = M[r][c];
+      if (f === 0) continue;
+      for (let k = 0; k < 2 * p; k++) M[r][k] -= f * M[c][k];
+    }
+  }
+  return M.map((row) => row.slice(p));
+}
+
+// src/analysis/coordinate-series.ts
+var MS_PER_YEAR = 365.25 * 864e5;
+var TWO_PI = 2 * Math.PI;
+var MIN_SIGMA_M = 5e-4;
+function lsq(A, y, w) {
+  const p = A[0]?.length ?? 0;
+  const N = Array.from({ length: p }, () => new Array(p).fill(0));
+  const b = new Array(p).fill(0);
+  for (let i = 0; i < A.length; i++) {
+    const a = A[i];
+    for (let j = 0; j < p; j++) {
+      b[j] += w[i] * a[j] * y[i];
+      for (let k = 0; k < p; k++) N[j][k] += w[i] * a[j] * a[k];
+    }
+  }
+  const M = N.map((row, i) => [
+    ...row,
+    ...Array.from({ length: p }, (_, j) => i === j ? 1 : 0)
+  ]);
+  for (let c = 0; c < p; c++) {
+    let piv = c;
+    for (let r = c + 1; r < p; r++)
+      if (Math.abs(M[r][c]) > Math.abs(M[piv][c])) piv = r;
+    if (Math.abs(M[piv][c]) < 1e-12) return null;
+    [M[c], M[piv]] = [M[piv], M[c]];
+    const d = M[c][c];
+    for (let k = 0; k < 2 * p; k++) M[c][k] /= d;
+    for (let r = 0; r < p; r++) {
+      if (r === c) continue;
+      const f = M[r][c];
+      if (f === 0) continue;
+      for (let k = 0; k < 2 * p; k++) M[r][k] -= f * M[c][k];
+    }
+  }
+  const Ninv = M.map((row) => row.slice(p));
+  const x = Ninv.map((row) => row.reduce((s, v, k) => s + v * b[k], 0));
+  return { x, Ninv };
+}
+function median2(xs) {
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function robustSigma(xs) {
+  if (xs.length < 2) return 0;
+  const m = median2(xs);
+  return 1.4826 * median2(xs.map((x) => Math.abs(x - m)));
+}
+function designRow(tMs, d) {
+  const dt = (tMs - d.refEpochMs) / MS_PER_YEAR;
+  const row = [1, dt];
+  for (const j of d.jumps) row.push(tMs >= j ? 1 : 0);
+  if (d.seasonal) {
+    const ph = TWO_PI * (tMs / MS_PER_YEAR);
+    row.push(Math.sin(ph), Math.cos(ph), Math.sin(2 * ph), Math.cos(2 * ph));
+  }
+  return row;
+}
+function fitComponent(t, y, w, used, d) {
+  const A = [];
+  const yy = [];
+  const ww = [];
+  for (let i = 0; i < t.length; i++) {
+    if (!used[i]) continue;
+    A.push(designRow(t[i], d));
+    yy.push(y[i]);
+    ww.push(w[i]);
+  }
+  if (A.length <= (A[0]?.length ?? 0)) return null;
+  const s = lsq(A, yy, ww);
+  if (!s) return null;
+  const residuals = t.map(
+    (ti, i) => y[i] - designRow(ti, d).reduce((acc, a, k) => acc + a * s.x[k], 0)
+  );
+  let wrss = 0;
+  let sumW = 0;
+  for (let i = 0; i < t.length; i++) {
+    if (!used[i]) continue;
+    wrss += w[i] * residuals[i] ** 2;
+    sumW += w[i];
+  }
+  return { ...s, wrss, sumW, residuals };
+}
+function fitCoordinateSeries(samples, opts = {}) {
+  const pts = [...samples].sort((a, b) => a.tMs - b.tMs);
+  if (pts.length < 5) return null;
+  const t = pts.map((p) => p.tMs);
+  const spanYears = (t[t.length - 1] - t[0]) / MS_PER_YEAR;
+  if (spanYears <= 0) return null;
+  const ref = [0, 1, 2].map(
+    (k2) => median2(pts.map((p) => p.ecef[k2]))
+  );
+  const [lat, lon] = ecefToGeodetic(ref[0], ref[1], ref[2]);
+  const sl = Math.sin(lat);
+  const cl = Math.cos(lat);
+  const so = Math.sin(lon);
+  const co = Math.cos(lon);
+  const enu = pts.map((p) => {
+    const dx = p.ecef[0] - ref[0];
+    const dy = p.ecef[1] - ref[1];
+    const dz = p.ecef[2] - ref[2];
+    return [
+      -so * dx + co * dy,
+      -sl * co * dx - sl * so * dy + cl * dz,
+      cl * co * dx + cl * so * dy + sl * dz
+    ];
+  });
+  const weights = [0, 1, 2].map(
+    (k2) => pts.map((p) => {
+      const s = p.sigmaEnu?.[k2];
+      return s && s > 0 ? 1 / Math.max(s, MIN_SIGMA_M) ** 2 : 1;
+    })
+  );
+  const series = [0, 1, 2].map((k2) => enu.map((v) => v[k2]));
+  const seasonal = opts.seasonal === "auto" || opts.seasonal === void 0 ? spanYears >= 2 : opts.seasonal;
+  const design = {
+    refEpochMs: opts.refEpochMs ?? (t[0] + t[t.length - 1]) / 2,
+    jumps: [...opts.jumps ?? []].filter((j) => j > t[0] && j <= t[t.length - 1]).sort((a, b) => a - b),
+    seasonal
+  };
+  const detected = /* @__PURE__ */ new Set();
+  const k = opts.outlierK ?? 4;
+  const used = pts.map(() => true);
+  const fitAll = () => [0, 1, 2].map(
+    (c) => fitComponent(t, series[c], weights[c], used, design)
+  );
+  const robustPass = () => {
+    for (let iter = 0; iter < 10; iter++) {
+      const sol2 = fitAll();
+      if (sol2.some((s) => !s)) return null;
+      const scales = sol2.map(
+        (s) => Math.max(robustSigma(s.residuals.filter((_, i) => used[i])), 1e-4)
+      );
+      let changed = false;
+      for (let i = 0; i < t.length; i++) {
+        const bad = sol2.some(
+          (s, c) => Math.abs(s.residuals[i]) > k * scales[c]
+        );
+        if (bad === used[i]) {
+          used[i] = !bad;
+          changed = true;
+        }
+      }
+      if (!changed) return sol2;
+    }
+    return fitAll();
+  };
+  let sol = robustPass();
+  if (!sol) return null;
+  if (opts.detectJumps ?? true) {
+    const minSide = opts.minSamplesPerSide ?? 5;
+    for (let added = 0; added < (opts.maxJumps ?? 3); added++) {
+      const idx = t.map((_, i) => i).filter((i) => used[i]);
+      const nUsed = idx.length;
+      const bicOf = (s, p) => s.reduce((acc, c) => acc + nUsed * Math.log(c.wrss / c.sumW), 0) + 3 * p * Math.log(nUsed);
+      const p0 = designRow(t[0], design).length;
+      const bic0 = bicOf(sol, p0);
+      let best = null;
+      for (let j = minSide; j <= nUsed - minSide; j++) {
+        const tj = (t[idx[j - 1]] + t[idx[j]]) / 2;
+        if (design.jumps.some((x) => Math.abs(x - tj) < 7 * 864e5))
+          continue;
+        const trial = {
+          ...design,
+          jumps: [...design.jumps, tj].sort((a, b) => a - b)
+        };
+        const s = [0, 1, 2].map(
+          (c) => fitComponent(t, series[c], weights[c], used, trial)
+        );
+        if (s.some((x) => !x)) continue;
+        const bic = bicOf(s, p0 + 1);
+        if (!best || bic < best.bic)
+          best = { tMs: tj, bic, sol: s };
+      }
+      if (!best || bic0 - best.bic <= 10) break;
+      design.jumps = [...design.jumps, best.tMs].sort((a, b) => a - b);
+      detected.add(best.tMs);
+      sol = robustPass();
+      if (!sol) return null;
+    }
+  }
+  const nJ = design.jumps.length;
+  const component = (c) => {
+    const s = sol[c];
+    const nUsed = used.filter(Boolean).length;
+    const p = s.x.length;
+    const vf = nUsed > p ? s.wrss / (nUsed - p) : 1;
+    const amp = (i) => seasonal ? Math.hypot(s.x[i], s.x[i + 1]) : null;
+    const noise = opts.noiseModel ?? true ? fitWhiteFlicker(
+      t.flatMap((ti, i) => used[i] ? [designRow(ti, design)] : []),
+      series[c].filter((_, i) => used[i]),
+      t.flatMap((ti, i) => used[i] ? [ti / MS_PER_YEAR] : [])
+    ) : null;
+    return {
+      offset: s.x[0],
+      velocity: s.x[1],
+      velocitySigma: Math.sqrt(s.Ninv[1][1] * vf),
+      velocitySigmaRealistic: noise?.velocitySigma ?? null,
+      flickerShare: noise?.flickerShare ?? null,
+      steps: s.x.slice(2, 2 + nJ),
+      annualAmplitude: amp(2 + nJ),
+      semiannualAmplitude: amp(4 + nJ),
+      wrms: Math.sqrt(s.wrss / s.sumW)
+    };
+  };
+  const points = pts.map((p, i) => ({
+    tMs: p.tMs,
+    enu: enu[i],
+    model: [0, 1, 2].map((c) => series[c][i] - sol[c].residuals[i]),
+    outlier: !used[i]
+  }));
+  return {
+    refEcef: ref,
+    refEpochMs: design.refEpochMs,
+    e: component(0),
+    n: component(1),
+    u: component(2),
+    jumps: design.jumps.map((tMs) => ({ tMs, detected: detected.has(tMs) })),
+    points,
+    spanYears,
+    used: used.filter(Boolean).length,
+    outliers: used.filter((u) => !u).length,
+    seasonal
+  };
+}
+
+// src/analysis/network-alignment.ts
+function applyHelmertFit(x, f) {
+  const [r1, r2, r3] = f.r;
+  return [
+    x[0] + f.t[0] + f.d * x[0] - r3 * x[1] + r2 * x[2],
+    x[1] + f.t[1] + r3 * x[0] + f.d * x[1] - r1 * x[2],
+    x[2] + f.t[2] - r2 * x[0] + r1 * x[1] + f.d * x[2]
+  ];
+}
+function solve(N, b) {
+  const n = b.length;
+  const M = N.map((row, i) => [...row, b[i]]);
+  for (let c = 0; c < n; c++) {
+    let p = c;
+    for (let r = c + 1; r < n; r++)
+      if (Math.abs(M[r][c]) > Math.abs(M[p][c])) p = r;
+    if (Math.abs(M[p][c]) < 1e-6) return null;
+    [M[c], M[p]] = [M[p], M[c]];
+    for (let r = 0; r < n; r++) {
+      if (r === c) continue;
+      const f = M[r][c] / M[c][c];
+      for (let k = c; k <= n; k++) M[r][k] -= f * M[c][k];
+    }
+  }
+  return M.map((row, i) => row[n] / row[i]);
+}
+function estimateHelmert(from, to, opts = {}) {
+  const model = opts.model ?? "translation";
+  const nPar = model === "translation" ? 3 : 7;
+  const minRefs = opts.minRefs ?? (model === "translation" ? 3 : 4);
+  const maxRes = opts.maxResidualM ?? 0.015;
+  if (from.length !== to.length) return null;
+  const used = from.map(() => true);
+  const c = [0, 1, 2].map(
+    (k) => from.reduce((s, p) => s + p[k], 0) / Math.max(from.length, 1)
+  );
+  for (; ; ) {
+    const idx = used.flatMap((u, i) => u ? [i] : []);
+    if (idx.length < minRefs || idx.length * 3 <= nPar) return null;
+    const N = Array.from(
+      { length: nPar },
+      () => new Array(nPar).fill(0)
+    );
+    const b = new Array(nPar).fill(0);
+    for (const i of idx) {
+      const x = [from[i][0] - c[0], from[i][1] - c[1], from[i][2] - c[2]];
+      for (let k = 0; k < 3; k++) {
+        const row = new Array(nPar).fill(0);
+        row[k] = 1;
+        if (nPar === 7) {
+          if (k === 0) {
+            row[4] = x[2];
+            row[5] = -x[1];
+          } else if (k === 1) {
+            row[3] = -x[2];
+            row[5] = x[0];
+          } else {
+            row[3] = x[1];
+            row[4] = -x[0];
+          }
+          row[6] = x[k];
+        }
+        const y = to[i][k] - from[i][k];
+        for (let a = 0; a < nPar; a++) {
+          b[a] += row[a] * y;
+          for (let bb = 0; bb < nPar; bb++) N[a][bb] += row[a] * row[bb];
+        }
+      }
+    }
+    const p = solve(N, b);
+    if (!p) return null;
+    const r = nPar === 7 ? [p[3], p[4], p[5]] : [0, 0, 0];
+    const d = nPar === 7 ? p[6] : 0;
+    const t = [
+      p[0] - (d * c[0] - r[2] * c[1] + r[1] * c[2]),
+      p[1] - (r[2] * c[0] + d * c[1] - r[0] * c[2]),
+      p[2] - (-r[1] * c[0] + r[0] * c[1] + d * c[2])
+    ];
+    const fit = { model, t, r, d, residuals: [], used, rms: 0 };
+    fit.residuals = from.map((x, i) => {
+      const y = applyHelmertFit(x, fit);
+      return [to[i][0] - y[0], to[i][1] - y[1], to[i][2] - y[2]];
+    });
+    let worst = -1;
+    let worstNorm = maxRes;
+    let ss = 0;
+    for (const i of idx) {
+      const n = Math.hypot(...fit.residuals[i]);
+      ss += n * n;
+      if (n > worstNorm) {
+        worstNorm = n;
+        worst = i;
+      }
+    }
+    fit.rms = Math.sqrt(ss / (3 * idx.length));
+    if (worst < 0 || idx.length <= minRefs) {
+      fit.used = [...used];
+      return fit;
+    }
+    used[worst] = false;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CompletenessAccumulator,
@@ -1931,8 +2453,11 @@ async function analyzeQuality(file, header, onProgress, signal) {
   IonoAccumulator,
   MultipathAccumulator,
   analyzeQuality,
+  applyHelmertFit,
   applyIonoDcb,
   computeIonoRate,
   detrendIonoArcs,
+  estimateHelmert,
+  fitCoordinateSeries,
   parseSinexBiasDcb
 });

package/dist/analysis.d.cts

@@ -363,4 +363,138 @@ interface QualityResult {
 }
 declare function analyzeQuality(file: File, header: RinexHeader, onProgress?: (percent: number) => void, signal?: AbortSignal): Promise<QualityResult>;
 
-export { type CompleteSatSignal, type CompleteSignalStats, CompletenessAccumulator, type CompletenessResult, CycleSlipAccumulator, type CycleSlipEvent, type CycleSlipResult, type CycleSlipSignalStats, IonoAccumulator, type IonoDcbResult, type IonoPoint, type IonoRatePoint, type IonoRateSeries, type IonoResult, type IonoSeries, MultipathAccumulator, type MultipathPoint, type MultipathResult, type MultipathSeries, type MultipathSignalStat, type QualityResult, type SatDcbMap, analyzeQuality, applyIonoDcb, computeIonoRate, detrendIonoArcs, parseSinexBiasDcb };
+/** One position solution (e.g. a daily PPP result). */
+interface CoordinateSample {
+    /** Epoch of the solution (ms), e.g. the session midpoint. */
+    tMs: number;
+    /** Position, ECEF (m), all in one reference frame. */
+    ecef: readonly [number, number, number];
+    /** Formal 1σ in East/North/Up (m), if known. */
+    sigmaEnu?: readonly [number, number, number];
+}
+interface SeriesFitOptions {
+    /** Known step epochs (ms): antenna/receiver changes, earthquakes… */
+    jumps?: number[];
+    /** Search for further jumps (BIC). Default true. */
+    detectJumps?: boolean;
+    /** Most jumps the search adds. Default 3. */
+    maxJumps?: number;
+    /** Annual + semi-annual terms: true, false or 'auto' (span ≥ 2 years). */
+    seasonal?: boolean | 'auto';
+    /** Outlier threshold in robust standard deviations. Default 4. */
+    outlierK?: number;
+    /** Reference epoch for the offset (ms). Default: middle of the span. */
+    refEpochMs?: number;
+    /** Samples a detected jump needs on each side. Default 5. */
+    minSamplesPerSide?: number;
+    /** Fit white + flicker noise for realistic velocity sigmas. Default true. */
+    noiseModel?: boolean;
+}
+interface SeriesComponent {
+    /** Value at the reference epoch (m), relative to the reference position. */
+    offset: number;
+    /** Velocity (m/yr). */
+    velocity: number;
+    /** White-noise formal 1σ of the velocity, scaled by the variance factor. */
+    velocitySigma: number;
+    /** Velocity 1σ under a white + flicker noise model fitted by maximum
+     *  likelihood — the realistic uncertainty; null if the series is too
+     *  short or `noiseModel` is off. */
+    velocitySigmaRealistic: number | null;
+    /** Share of the residual variance the noise fit attributes to flicker. */
+    flickerShare: number | null;
+    /** Step size at each jump (m), in the order of `SeriesFit.jumps`. */
+    steps: number[];
+    /** Annual / semi-annual amplitudes (m), when fitted. */
+    annualAmplitude: number | null;
+    semiannualAmplitude: number | null;
+    /** Weighted RMS of the residuals of the used samples (m). */
+    wrms: number;
+}
+interface SeriesPoint {
+    tMs: number;
+    /** Position relative to the reference position, local ENU (m). */
+    enu: [number, number, number];
+    /** Model value at tMs (m). */
+    model: [number, number, number];
+    /** Rejected as an outlier. */
+    outlier: boolean;
+}
+interface SeriesFit {
+    /** Median position the ENU values are relative to (ECEF, m). */
+    refEcef: [number, number, number];
+    refEpochMs: number;
+    e: SeriesComponent;
+    n: SeriesComponent;
+    u: SeriesComponent;
+    /** Jumps in the model, chronological; `detected` = found by the search. */
+    jumps: {
+        tMs: number;
+        detected: boolean;
+    }[];
+    points: SeriesPoint[];
+    spanYears: number;
+    used: number;
+    outliers: number;
+    seasonal: boolean;
+}
+/**
+ * Fit the trajectory model to a station's position series. Needs at least
+ * five samples spanning some time; the velocity is meaningful once the span
+ * covers a good part of a year (seasonal signals otherwise alias into it).
+ */
+declare function fitCoordinateSeries(samples: readonly CoordinateSample[], opts?: SeriesFitOptions): SeriesFit | null;
+
+/**
+ * Network alignment: the transformation that maps one day's solutions of
+ * reference stations onto their known coordinates, applied to every station
+ * of that day.
+ *
+ * Daily PPP positions share errors over a region — orbit and clock errors
+ * of the day, the frame realisation of the product — so a station's series
+ * scatters more than the station moves. Estimating those common errors from
+ * reference stations with trusted coordinates (IGS/EUREF, propagated to the
+ * day by their velocities) and removing them is the regional counterpart of
+ * Bernese's datum definition by minimum constraints, and of "common-mode
+ * filtering" in GNSS time-series work.
+ *
+ * Model (position-vector convention, small angles, as `applyHelmert`):
+ *   x_ref = x + t + d·x + r × x
+ * 'translation' estimates t only — the robust choice for a regional network,
+ * where rotations are nearly indistinguishable from translations; 'similarity'
+ * adds rotation and scale (7 parameters) for a continental or wider spread.
+ */
+type HelmertModel = 'translation' | 'similarity';
+interface HelmertFit {
+    model: HelmertModel;
+    /** Translation (m). */
+    t: [number, number, number];
+    /** Rotation (rad), zero for 'translation'. */
+    r: [number, number, number];
+    /** Scale (unitless, e.g. 1e-9 = 1 ppb), zero for 'translation'. */
+    d: number;
+    /** Residual (reference − transformed) per input pair, ECEF (m). */
+    residuals: [number, number, number][];
+    /** Pairs kept in the final fit (false = rejected reference). */
+    used: boolean[];
+    /** RMS of the used residuals, per coordinate (m). */
+    rms: number;
+}
+interface HelmertOptions {
+    model?: HelmertModel;
+    /** A reference whose 3-D residual exceeds this is dropped (m). Default 0.015. */
+    maxResidualM?: number;
+    /** Keep at least this many references. Default: 3 (translation) or 4. */
+    minRefs?: number;
+}
+type V3 = readonly [number, number, number];
+/** Apply an estimated transformation to one position. */
+declare function applyHelmertFit(x: V3, f: HelmertFit): [number, number, number];
+/**
+ * Estimate the transformation from `from` (e.g. the day's PPP positions of
+ * the reference stations) to `to` (their known coordinates at that epoch).
+ * Rejects the worst-fitting reference while any exceeds `maxResidualM`.
+ */
+declare function estimateHelmert(from: readonly V3[], to: readonly V3[], opts?: HelmertOptions): HelmertFit | null;
+
+export { type CompleteSatSignal, type CompleteSignalStats, CompletenessAccumulator, type CompletenessResult, type CoordinateSample, CycleSlipAccumulator, type CycleSlipEvent, type CycleSlipResult, type CycleSlipSignalStats, type HelmertFit, type HelmertModel, type HelmertOptions, IonoAccumulator, type IonoDcbResult, type IonoPoint, type IonoRatePoint, type IonoRateSeries, type IonoResult, type IonoSeries, MultipathAccumulator, type MultipathPoint, type MultipathResult, type MultipathSeries, type MultipathSignalStat, type QualityResult, type SatDcbMap, type SeriesComponent, type SeriesFit, type SeriesFitOptions, type SeriesPoint, analyzeQuality, applyHelmertFit, applyIonoDcb, computeIonoRate, detrendIonoArcs, estimateHelmert, fitCoordinateSeries, parseSinexBiasDcb };