@neilberkman/sidereon 0.14.0 → 0.16.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,86 @@ export class CoverageGrid {
     readonly stationCount: number;
 }
 
+/**
+ * Stateful opt-in latch for SGP4 decay-like failures.
+ *
+ * Pass one latch per satellite to [`Tle.propagateWithDecayLatch`]. The first
+ * decay-like SGP4 failure records the requested epoch in minutes since the TLE
+ * epoch; later requests at the same or a later epoch throw immediately through
+ * the core latch instead of returning a raw post-decay state.
+ */
+export class DecayLatch {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Clear the recorded decay state.
+     */
+    clear(): void;
+    /**
+     * Construct an empty decay latch.
+     */
+    constructor();
+    /**
+     * First observed decay-like epoch, in minutes since the TLE epoch.
+     */
+    readonly firstFailingEpochMinutes: number | undefined;
+}
+
+/**
+ * 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.
@@ -1517,6 +1625,34 @@ export class DtedTerrain {
     constructor(root: string);
 }
 
+/**
+ * Earth figure used for conical eclipse shadow geometry.
+ */
+export enum EarthShadowModel {
+    /**
+     * Spherical Earth using the core mean Earth radius.
+     */
+    Spherical = 0,
+    /**
+     * WGS84 oblate Earth approximation by polar-axis scaling.
+     */
+    Wgs84Oblate = 1,
+}
+
+/**
+ * EGM2008 raster spacing for NGA row-framed interpolation grids.
+ */
+export enum Egm2008GridSpacing {
+    /**
+     * The 1-arcminute EGM2008 grid.
+     */
+    OneMinute = 0,
+    /**
+     * The 2.5-arcminute EGM2008 grid.
+     */
+    TwoPointFiveMinute = 1,
+}
+
 /**
  * Loaded EGM96 15-arcminute geoid grid for explicit terrain datum conversion.
  */
@@ -1619,6 +1755,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)`.
@@ -1801,6 +1958,17 @@ export class FrameStates {
     readonly velocityKmS: Float64Array;
 }
 
+/**
+ * WGS84 geodesic input failure class exposed as a stable enum symbol.
+ */
+export enum GeodesicError {
+    /**
+     * A latitude, longitude, azimuth, or distance was outside the accepted
+     * numeric domain.
+     */
+    InvalidInput = 0,
+}
+
 /**
  * A regular latitude/longitude grid of geoid undulation samples with bilinear
  * interpolation, wrapping a real (loaded) geoid model.
@@ -1816,6 +1984,23 @@ export class GeoidGrid {
      * Ellipsoidal height from orthometric height and radians.
      */
     ellipsoidalHeightRad(orthometric_height_m: number, lat_rad: number, lon_rad: number): number;
+    /**
+     * Parse a full NGA EGM2008 row-framed interpolation raster.
+     *
+     * The byte stream must contain one north-to-south Fortran sequential record
+     * per latitude row at the requested spacing. Use
+     * [`fromEgm2008RasterWindow`] for small cropped fixtures or partial loads.
+     */
+    static fromEgm2008Raster(bytes: Uint8Array, spacing: Egm2008GridSpacing): GeoidGrid;
+    /**
+     * Parse a cropped NGA EGM2008 row-framed interpolation raster window.
+     *
+     * `latMinDeg` and `lonMinDeg` are the southwest node of the loaded grid.
+     * `nLat` and `nLon` are the latitude and longitude node counts in the byte
+     * stream. Queries use the same undulation methods as every other
+     * [`GeoidGrid`].
+     */
+    static fromEgm2008RasterWindow(bytes: Uint8Array, spacing: Egm2008GridSpacing, lat_min_deg: number, lon_min_deg: number, n_lat: number, n_lon: number): GeoidGrid;
     /**
      * Parse an EGM96 `WW15MGH.DAC` byte buffer into a full-resolution grid.
      */
@@ -2126,6 +2311,93 @@ export class GroundTrack {
     readonly lonDeg: Float64Array;
 }
 
+/**
+ * Helmert parameters in the units used by the published catalog tables.
+ */
+export class HelmertParameters {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Construct Helmert parameters from translation millimetres, scale parts
+     * per billion, and rotation milliarcseconds.
+     */
+    constructor(translation_mm: Float64Array, scale_ppb: number, rotation_mas: Float64Array);
+    /**
+     * Rotation components `[Rx, Ry, Rz]`, in milliarcseconds.
+     */
+    readonly rotationMas: Float64Array;
+    /**
+     * Scale difference, in parts per billion.
+     */
+    readonly scalePpb: number;
+    /**
+     * Translation components `[Tx, Ty, Tz]`, in millimetres.
+     */
+    readonly translationMm: Float64Array;
+}
+
+/**
+ * Helmert parameter rates in the units used by the published catalog tables.
+ */
+export class HelmertRates {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Construct Helmert parameter rates from translation millimetres per year,
+     * scale parts per billion per year, and rotation milliarcseconds per year.
+     */
+    constructor(translation_mm_per_year: Float64Array, scale_ppb_per_year: number, rotation_mas_per_year: Float64Array);
+    /**
+     * Rotation rates `[Rx, Ry, Rz]`, in milliarcseconds per year.
+     */
+    readonly rotationMasPerYear: Float64Array;
+    /**
+     * Scale rate, in parts per billion per year.
+     */
+    readonly scalePpbPerYear: number;
+    /**
+     * Translation rates `[Tx, Ty, Tz]`, in millimetres per year.
+     */
+    readonly translationMmPerYear: Float64Array;
+}
+
+/**
+ * One published 14-parameter Helmert catalog entry.
+ */
+export class HelmertTransform {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Evaluate the seven Helmert parameters at a decimal year.
+     */
+    parametersAt(epoch_year: number): HelmertParameters;
+    /**
+     * Published source frame for the forward transform.
+     */
+    readonly from: TerrestrialFrame;
+    /**
+     * Parameters at `referenceEpochYear`.
+     */
+    readonly parameters: HelmertParameters;
+    /**
+     * Published table or memo that supplied this entry.
+     */
+    readonly provenance: string;
+    /**
+     * Linear rates of the seven Helmert parameters.
+     */
+    readonly rates: HelmertRates;
+    /**
+     * Parameter reference epoch, expressed as a decimal year.
+     */
+    readonly referenceEpochYear: number;
+    /**
+     * Published target frame for the forward transform.
+     */
+    readonly to: TerrestrialFrame;
+}
+
 /**
  * A point in time, tagged UTC, with the precise time scales resolved.
  *
@@ -4110,6 +4382,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;
@@ -4189,6 +4486,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.
  */
@@ -5024,82 +5404,246 @@ export class SbasCorrectionStore {
 }
 
 /**
- * Per-constellation single-frequency pseudorange code-selection policy. Build
- * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
- * the static `defaultFor(version)`.
+ * Index-aligned SBAS error model for protection-level geometry rows.
  */
-export class SignalPolicy {
+export class SbasErrorModel {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * The core default pseudorange policy for a RINEX version.
-     */
-    static defaultFor(version: number): SignalPolicy;
-    /**
-     * An empty policy with no constellation preferences.
-     */
-    constructor();
-    /**
-     * Return a copy with one constellation's preference list set.
+     * 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.
      */
-    withSystem(system: GnssSystem, codes: string[]): SignalPolicy;
-}
-
-/**
- * Reason a carrier-phase arc split was flagged.
- */
-export enum SlipReason {
+    static fromStore(store: SbasCorrectionStore, geo: string, geometry: any, airborne: AirborneModel | null | undefined, epoch_j2000_s: number, degradation?: DegradationParams | null): SbasErrorModel;
     /**
-     * Loss-of-lock indicator bit 0 set on either band.
+     * 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.
      */
-    Lli = 0,
+    constructor(rows: any);
     /**
-     * Gap to the previous usable sample exceeded the threshold.
+     * Return the row for a satellite token, or `undefined` if it is absent.
      */
-    DataGap = 1,
+    rowFor(id: string): SbasSisError | undefined;
     /**
-     * Geometry-free phase step exceeded the threshold.
+     * Number of range-error rows in the model.
      */
-    GeometryFree = 2,
+    readonly rowCount: number;
     /**
-     * Melbourne-Wubbena step exceeded the threshold.
+     * Error-model rows as plain objects.
      */
-    MelbourneWubbena = 3,
+    readonly rows: any;
 }
 
 /**
- * Cycle-slip classification for one input epoch.
+ * Fixed SBAS protection-level multipliers.
  */
-export class SlipResult {
-    private constructor();
+export class SbasKMultipliers {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * Current geometry-free phase, metres, or `undefined`.
+     * En-route through non-precision-approach SBAS K multipliers.
      */
-    readonly gfM: number | undefined;
+    static enRouteNpa(): SbasKMultipliers;
     /**
-     * Current Melbourne-Wubbena combination, metres, or `undefined`.
+     * Construct SBAS horizontal and vertical K multipliers.
+     *
+     * Both values must be positive finite numbers.
      */
-    readonly mwM: number | undefined;
+    constructor(k_h: number, k_v: number);
     /**
-     * Slip reasons in deterministic API order.
+     * Precision-approach SBAS K multipliers.
      */
-    readonly reasons: any[];
+    static precisionApproach(): SbasKMultipliers;
     /**
-     * Whether the epoch was skipped because a frequency was unavailable.
+     * Horizontal K multiplier.
      */
-    readonly skipped: boolean;
+    readonly kH: number;
     /**
-     * Whether any slip reason was flagged.
+     * Vertical K multiplier.
      */
-    readonly slip: boolean;
+    readonly kV: number;
 }
 
 /**
- * Hatch-smoothed single-frequency code output for one epoch.
+ * SBAS protection-level input or numerical failure.
  */
-export class SmoothCodeResult {
+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
+ * the static `defaultFor(version)`.
+ */
+export class SignalPolicy {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The core default pseudorange policy for a RINEX version.
+     */
+    static defaultFor(version: number): SignalPolicy;
+    /**
+     * An empty policy with no constellation preferences.
+     */
+    constructor();
+    /**
+     * Return a copy with one constellation's preference list set.
+     */
+    withSystem(system: GnssSystem, codes: string[]): SignalPolicy;
+}
+
+/**
+ * Reason a carrier-phase arc split was flagged.
+ */
+export enum SlipReason {
+    /**
+     * Loss-of-lock indicator bit 0 set on either band.
+     */
+    Lli = 0,
+    /**
+     * Gap to the previous usable sample exceeded the threshold.
+     */
+    DataGap = 1,
+    /**
+     * Geometry-free phase step exceeded the threshold.
+     */
+    GeometryFree = 2,
+    /**
+     * Melbourne-Wubbena step exceeded the threshold.
+     */
+    MelbourneWubbena = 3,
+}
+
+/**
+ * Cycle-slip classification for one input epoch.
+ */
+export class SlipResult {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Current geometry-free phase, metres, or `undefined`.
+     */
+    readonly gfM: number | undefined;
+    /**
+     * Current Melbourne-Wubbena combination, metres, or `undefined`.
+     */
+    readonly mwM: number | undefined;
+    /**
+     * Slip reasons in deterministic API order.
+     */
+    readonly reasons: any[];
+    /**
+     * Whether the epoch was skipped because a frequency was unavailable.
+     */
+    readonly skipped: boolean;
+    /**
+     * Whether any slip reason was flagged.
+     */
+    readonly slip: boolean;
+}
+
+/**
+ * Hatch-smoothed single-frequency code output for one epoch.
+ */
+export class SmoothCodeResult {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
@@ -5827,6 +6371,247 @@ export class SunMoon {
     readonly sun: Float64Array;
 }
 
+/**
+ * A parsed CCSDS Tracking Data Message.
+ */
+export class Tdm {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Encode this TDM as canonical CCSDS KVN text.
+     */
+    toKvnString(): string;
+    /**
+     * Header comments in parse order.
+     */
+    readonly comments: string[];
+    /**
+     * Optional `CREATION_DATE` header value.
+     */
+    readonly creationDate: string | undefined;
+    /**
+     * Header fields not part of the common modeled header.
+     */
+    readonly headerFields: TdmField[];
+    /**
+     * Optional `MESSAGE_ID` header value.
+     */
+    readonly messageId: string | undefined;
+    /**
+     * Optional `ORIGINATOR` header value.
+     */
+    readonly originator: string | undefined;
+    /**
+     * Number of segments in the message.
+     */
+    readonly segmentCount: number;
+    /**
+     * Metadata/data segments in message order.
+     */
+    readonly segments: TdmSegment[];
+    /**
+     * The `CCSDS_TDM_VERS` header value.
+     */
+    readonly version: string;
+}
+
+/**
+ * One time-tagged TDM tracking data record.
+ */
+export class TdmDataRecord {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Raw epoch string.
+     */
+    readonly epoch: string;
+    /**
+     * Original data keyword.
+     */
+    readonly keyword: string;
+    /**
+     * Observable family label such as `"range"` or `"receiveFreq"`.
+     */
+    readonly observableKind: string;
+    /**
+     * Participant suffix for frequency records, or `undefined`.
+     */
+    readonly observableParticipant: number | undefined;
+    /**
+     * Original name for a table-defined keyword modeled as `other`.
+     */
+    readonly otherObservable: string | undefined;
+    /**
+     * Numeric value plus exact decimal token.
+     */
+    readonly scalar: TdmScalar;
+    /**
+     * Canonical unit label assigned by CCSDS 503.0-B-2.
+     */
+    readonly unit: string;
+    /**
+     * Parsed numeric observable value.
+     */
+    readonly value: number;
+    /**
+     * Exact decimal token used for KVN encoding.
+     */
+    readonly valueText: string;
+}
+
+/**
+ * A TDM data block.
+ */
+export class TdmDataSection {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Data-section comments in parse order.
+     */
+    readonly comments: string[];
+    /**
+     * Data records in parse order.
+     */
+    readonly records: TdmDataRecord[];
+}
+
+/**
+ * A KVN key/value field preserved in parse order.
+ */
+export class TdmField {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The KVN keyword.
+     */
+    readonly key: string;
+    /**
+     * The trimmed KVN value.
+     */
+    readonly value: string;
+}
+
+/**
+ * Metadata extracted from a TDM `META_START` / `META_STOP` block.
+ */
+export class TdmMetadata {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Return the last metadata value for `key`, or `undefined`.
+     */
+    getLast(key: string): string | undefined;
+    /**
+     * Metadata comments in parse order.
+     */
+    readonly comments: string[];
+    /**
+     * Raw metadata fields in parse order.
+     */
+    readonly fields: TdmField[];
+    /**
+     * Optional `MODE` value.
+     */
+    readonly mode: string | undefined;
+    /**
+     * Parsed `PARTICIPANT_n` entries.
+     */
+    readonly participants: TdmParticipant[];
+    /**
+     * Parsed `PATH`, `PATH_1`, and `PATH_2` entries.
+     */
+    readonly paths: TdmPath[];
+    /**
+     * Range unit label used by `RANGE` records.
+     */
+    readonly rangeUnits: string;
+    /**
+     * Optional `TIME_SYSTEM` value.
+     */
+    readonly timeSystem: string | undefined;
+    /**
+     * Optional `TIMETAG_REF` value.
+     */
+    readonly timetagRef: string | undefined;
+}
+
+/**
+ * One named TDM tracking participant.
+ */
+export class TdmParticipant {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Numeric suffix from `PARTICIPANT_n`.
+     */
+    readonly index: number;
+    /**
+     * Participant name.
+     */
+    readonly name: string;
+}
+
+/**
+ * A parsed TDM signal path from `PATH`, `PATH_1`, or `PATH_2`.
+ */
+export class TdmPath {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Path suffix for `PATH_n`, or `undefined` for unindexed `PATH`.
+     */
+    readonly index: number | undefined;
+    /**
+     * Original path keyword.
+     */
+    readonly key: string;
+    /**
+     * Participant indices listed in path order.
+     */
+    readonly participants: Uint8Array;
+}
+
+/**
+ * A numeric TDM record value plus its exact decimal token.
+ */
+export class TdmScalar {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Exact decimal or scientific-notation token read from the message.
+     */
+    readonly text: string;
+    /**
+     * Parsed finite `f64` value.
+     */
+    readonly value: number;
+}
+
+/**
+ * One TDM segment, consisting of metadata and data blocks.
+ */
+export class TdmSegment {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Tracking data records for this segment.
+     */
+    readonly data: TdmDataSection;
+    /**
+     * Metadata describing this segment's records.
+     */
+    readonly metadata: TdmMetadata;
+}
+
 /**
  * Terrain datum conversion and optional geoid-grid loading error variants.
  */
@@ -5960,6 +6745,28 @@ export class TerrainStoreTileIndex {
     readonly verticalDatum: VerticalDatum;
 }
 
+/**
+ * A supported terrestrial reference-frame realization.
+ */
+export enum TerrestrialFrame {
+    /**
+     * International Terrestrial Reference Frame 2020.
+     */
+    Itrf2020 = 0,
+    /**
+     * International Terrestrial Reference Frame 2014.
+     */
+    Itrf2014 = 1,
+    /**
+     * International Terrestrial Reference Frame 2008.
+     */
+    Itrf2008 = 2,
+    /**
+     * European Terrestrial Reference Frame 2020.
+     */
+    Etrf2020 = 3,
+}
+
 /**
  * A named time scale. The JS value matches the variant order below.
  */
@@ -6000,6 +6807,14 @@ export enum TimeScale {
      * QZSS system time (steered to GPST).
      */
     Qzsst = 8,
+    /**
+     * Geocentric Coordinate Time.
+     */
+    Tcg = 9,
+    /**
+     * Barycentric Coordinate Time.
+     */
+    Tcb = 10,
 }
 
 /**
@@ -6039,6 +6854,15 @@ export class Tle {
      * position (km) and velocity (km/s). Throws an `Error` on SGP4 failure.
      */
     propagate(epochs_unix_us: BigInt64Array): TlePropagation;
+    /**
+     * Propagate over unix-microsecond epochs with an opt-in decay latch.
+     *
+     * The returned TEME arrays match [`propagate`] until the first decay-like
+     * SGP4 failure. At that point the core latch records the failing epoch and
+     * this method throws. Later calls using the same latch at that epoch or a
+     * later one also throw, while raw [`propagate`] remains stateless.
+     */
+    propagateWithDecayLatch(epochs_unix_us: BigInt64Array, latch: DecayLatch): TlePropagation;
     /**
      * Re-encode the parsed elements as the two 69-character TLE lines (with
      * checksums), as a `[line1, line2]` string array. For a well-formed input
@@ -6363,6 +7187,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.
  *
@@ -6727,6 +7561,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.
  *
@@ -6999,6 +7841,14 @@ export function findTcaCandidates(primary_line1: string, primary_line2: string,
  */
 export function findTcaConjunctions(primary_line1: string, primary_line2: string, secondary_line1: string, secondary_line2: string, window_start_unix_micros: bigint, window_end_unix_micros: bigint, pc_options: any, options: any): any;
 
+/**
+ * Fit every satellite declared in a parsed ECEF SP3 precise product.
+ *
+ * The residual ledger is computed against the original Earth-fixed SP3
+ * observations by the core fit path.
+ */
+export function fitAllSp3EcefPreciseOrbits(sp3: Sp3, options: any): any;
+
 /**
  * Fit a piecewise reduced-orbit model: tile `[t0, t1]` into segments of
  * `segmentSeconds` and fit each independently.
@@ -7028,6 +7878,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.
  *
@@ -7054,11 +7923,46 @@ 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 ECEF SP3 precise product.
+ *
+ * `satellite` is an IGS token such as `"G01"`. SP3 position and optional
+ * velocity records are transformed from Earth-fixed coordinates through the
+ * core `TdbEarthOrientationProvider` before fitting.
+ */
+export function fitSp3EcefPreciseOrbit(sp3: Sp3, satellite: string, options: any): any;
+
+/**
+ * Fit selected satellite orbits from a parsed ECEF SP3 precise product.
+ *
+ * `satellites` is a string array of IGS tokens such as `["G01", "G02"]`.
+ * The Earth-fixed to inertial conversion is handled by the core provider.
+ */
+export function fitSp3EcefPreciseOrbits(sp3: Sp3, satellites: any, options: any): any;
+
+/**
+ * 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.
  *
@@ -7089,6 +7993,43 @@ export function forceJ2Acceleration(position_km: Float64Array, velocity_km_s: Fl
  */
 export function forceTwoBodyAcceleration(position_km: Float64Array, velocity_km_s: Float64Array): Float64Array;
 
+/**
+ * Return the built-in terrestrial frame catalog entries.
+ */
+export function frameCatalog(): HelmertTransform[];
+
+/**
+ * Return the published catalog entry for the requested forward direction.
+ */
+export function frameCatalogEntry(from: TerrestrialFrame, to: TerrestrialFrame): HelmertTransform | undefined;
+
+/**
+ * Propagate a station position from one decimal year to another.
+ *
+ * `positionM` and `velocityMPerYear` are length-3 arrays in metres and metres
+ * per year. Returns a length-3 array in metres. Delegates to
+ * `sidereon_core::frame_catalog::propagate_position`.
+ */
+export function frameCatalogPropagatePosition(position_m: Float64Array, velocity_m_per_year: Float64Array, from_epoch_year: number, to_epoch_year: number): Float64Array;
+
+/**
+ * Transform a Cartesian station position and optional velocity between frames.
+ *
+ * `positionM` is a length-3 metre array. `velocityMPerYear` may be `undefined`
+ * or a length-3 metres-per-year array. Returns a plain object with
+ * `positionM` and `velocityMPerYear` (`null` when no velocity was supplied).
+ */
+export function frameCatalogTransform(position_m: Float64Array, velocity_m_per_year: Float64Array | null | undefined, from: TerrestrialFrame, to: TerrestrialFrame, epoch_year: number): any;
+
+/**
+ * Propagate a station to a transform epoch, then transform it between frames.
+ *
+ * `positionEpochYear` is the epoch of the input coordinates. The transform is
+ * evaluated at `transformEpochYear`. Returns a plain object with `positionM`
+ * and `velocityMPerYear`.
+ */
+export function frameCatalogTransformFromEpoch(position_m: Float64Array, velocity_m_per_year: Float64Array, position_epoch_year: number, from: TerrestrialFrame, to: TerrestrialFrame, transform_epoch_year: number): any;
+
 /**
  * Build constellation identity records from a CelesTrak OMM JSON-array text.
  *
@@ -7148,6 +8089,32 @@ export function gamma(f1_hz: number, f2_hz: number): number;
  */
 export function gcrsToItrs(position_km: Float64Array, epochs_unix_us: BigInt64Array, skyfield_compat?: boolean | null): Float64Array;
 
+/**
+ * Solve the WGS84 direct geodesic problem.
+ *
+ * Inputs are point 1 latitude, longitude, forward azimuth, and geodesic
+ * distance. Angles are degrees and `distanceM` is metres. Returns
+ * `{ lat2Deg, lon2Deg, finalAzimuthDeg }`. Delegates to
+ * `sidereon_core::geodesic::geodesic_direct`.
+ */
+export function geodesicDirect(lat1_deg: number, lon1_deg: number, initial_azimuth_deg: number, distance_m: number): any;
+
+/**
+ * Stable string label for a [`GeodesicError`] enum value.
+ */
+export function geodesicErrorLabel(error: GeodesicError): string;
+
+/**
+ * Solve the WGS84 inverse geodesic problem.
+ *
+ * Inputs are point 1 latitude and longitude followed by point 2 latitude and
+ * longitude, all in degrees. Longitudes may be outside `[-180, 180]`. Returns
+ * `{ distanceM, initialAzimuthDeg, finalAzimuthDeg }`, with distance in metres
+ * and azimuths in degrees. Delegates to
+ * `sidereon_core::geodesic::geodesic_inverse`.
+ */
+export function geodesicInverse(lat1_deg: number, lon1_deg: number, lat2_deg: number, lon2_deg: number): any;
+
 /**
  * Convert a batch of geodetic coordinates to ITRS (ECEF).
  *
@@ -7690,6 +8657,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.
  *
@@ -7699,6 +8686,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.
  *
@@ -7781,6 +8773,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.
  */
@@ -7908,6 +8909,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
@@ -8060,6 +9069,11 @@ export function parseSpaceWeatherCsv(text: string): SpaceWeatherTable;
  */
 export function parseSpaceWeatherTxt(text: string): SpaceWeatherTable;
 
+/**
+ * Parse a CCSDS Tracking Data Message in KVN form.
+ */
+export function parseTdmKvn(text: string): Tdm;
+
 /**
  * Parse a multi-record TLE file (CelesTrak / Space-Track style) into named,
  * initialized [`Tle`] instances. Handles bare 2-line sets, 3-line name+line1+line2
@@ -8070,6 +9084,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.
  */
@@ -8181,7 +9203,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.
  */
@@ -8218,6 +9240,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.
  */
@@ -8228,6 +9269,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`.
  */
@@ -8341,12 +9387,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.
  *
@@ -8408,6 +9468,16 @@ export function selectSp3OverRange(products: Sp3[], start_epoch_j2000_s: number,
  */
 export function shadowFraction(satellite_position_km: Float64Array, sun_position_km: Float64Array): Float64Array;
 
+/**
+ * Shadow fraction in `[0, 1]` for position batches with an explicit Earth
+ * shadow model.
+ *
+ * `satellitePositionKm` and `sunPositionKm` are flat row-major `(n, 3)`
+ * `Float64Array`s. `EarthShadowModel.Spherical` is bit-identical to
+ * [`shadowFraction`].
+ */
+export function shadowFractionWithModel(satellite_position_km: Float64Array, sun_position_km: Float64Array, model: EarthShadowModel): Float64Array;
+
 /**
  * Shapiro-Wilk normality test on a residual set.
  *
@@ -8418,6 +9488,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.
@@ -8746,6 +9825,11 @@ export function terminatorLatitudeDeg(sub_solar_latitude_deg: number, sub_solar_
  */
 export function terrainStoreChecksum64(bytes: Uint8Array): bigint;
 
+/**
+ * Stable string label for a [`TerrestrialFrame`] enum value.
+ */
+export function terrestrialFrameLabel(frame: TerrestrialFrame): string;
+
 /**
  * Time deviation for explicit averaging factors.
  *
@@ -8853,6 +9937,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
@@ -8901,3 +9994,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 the core-provided `delta0` and `lambda0` values.
+ */
+export function wtestNoncentrality(alpha: number, power: number): any;