@neilberkman/sidereon 0.16.1 → 0.18.0

package/pkg-node/sidereon.d.ts

@@ -1371,6 +1371,20 @@ export class DgnssSolution {
     readonly usedSats: string[];
 }
 
+/**
+ * Early-late DLL processing mode for thermal-noise jitter.
+ */
+export enum DllProcessing {
+    /**
+     * Coherent early-minus-late processing.
+     */
+    Coherent = 0,
+    /**
+     * Non-coherent early-minus-late power processing with squaring loss.
+     */
+    NonCoherent = 1,
+}
+
 /**
  * GNSS dilution-of-precision scalars.
  */
@@ -1687,6 +1701,76 @@ export class EllipsoidalHeightM {
     readonly valueM: number;
 }
 
+/**
+ * Contiguous state and media-correction arrays from one emission batch.
+ */
+export class EmissionMediaBatch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Error message for row `index`, or `undefined` when the row has no error.
+     */
+    error(index: number): string | undefined;
+    /**
+     * Satellite clock offsets in seconds, with `NaN` for unavailable rows.
+     */
+    readonly clockS: Float64Array;
+    /**
+     * Number of satellite rows in the batch.
+     */
+    readonly count: number;
+    /**
+     * Per-row success and error messages as `{ ok, error }[]`.
+     */
+    readonly elementResults: any;
+    /**
+     * Ionospheric slant group delays in metres, with `NaN` for unavailable rows.
+     */
+    readonly ionosphereSlantDelayM: Float64Array;
+    /**
+     * Satellite ECEF positions as flat `[x0, y0, z0, ...]`, metres.
+     *
+     * Rows without a usable position are filled with `NaN`; check `statuses`
+     * before consuming the corresponding row.
+     */
+    readonly positionEcefM: Float64Array;
+    /**
+     * Per-row status labels, index-aligned with the numeric arrays.
+     */
+    readonly statusLabels: string[];
+    /**
+     * Per-row typed status values, index-aligned with the numeric arrays.
+     */
+    readonly statuses: any[];
+    /**
+     * Tropospheric slant delays in metres, with `NaN` for unavailable rows.
+     */
+    readonly troposphereDelayM: Float64Array;
+}
+
+/**
+ * Per-satellite status for an emission media batch row.
+ */
+export enum EmissionMediaStatus {
+    /**
+     * State, clock, and requested media corrections were produced.
+     */
+    Valid = 0,
+    /**
+     * The ephemeris product has no usable state for this satellite and epoch.
+     */
+    Gap = 1,
+    /**
+     * A state was available, but elevation was below the requested cutoff.
+     */
+    BelowElevationCutoff = 2,
+    /**
+     * A non-gap scalar evaluation error occurred.
+     */
+    Error = 3,
+}
+
 /**
  * Orthonormal encounter frame built from two relative states.
  */
@@ -1969,6 +2053,111 @@ export enum GeodesicError {
     InvalidInput = 0,
 }
 
+/**
+ * A geodesic polygon fence on WGS84.
+ */
+export class Geofence {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Containment probability for one position and uncertainty object.
+     *
+     * `uncertainty.kind` is one of `"enuCovarianceM2"`, `"ecefCovarianceM2"`,
+     * `"cepRadiusM"`, or `"horizontalRadius"`. `options.method` is
+     * `"boundaryNormal"` or `"planarQuadrature"`.
+     */
+    containmentProbability(lat_rad: number, lon_rad: number, height_m: number, uncertainty_value: any, options: any): number;
+    /**
+     * Boolean containment for one WGS84 geodetic position.
+     */
+    contains(lat_rad: number, lon_rad: number, height_m: number): boolean;
+    /**
+     * Probabilistic crossing detection over geodetic position estimates.
+     *
+     * `samples` is an array of `{ latRad, lonRad, heightM?, uncertainty }`.
+     * `options.enterConfidence` and `options.leaveConfidence` configure
+     * hysteresis; absent values use the core defaults.
+     */
+    crossingProbability(samples: any, options: any): any;
+    /**
+     * Signed distance to the fence boundary in metres.
+     */
+    distanceToBoundary(lat_rad: number, lon_rad: number, height_m: number): number;
+    /**
+     * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+     *
+     * `vertices` is `[latRad, lonRad, ...]`. Use `geofenceFromVertices3d`
+     * for `[latRad, lonRad, heightM, ...]` rows.
+     */
+    constructor(vertices: Float64Array);
+    /**
+     * Whether the core small-region planar path can evaluate this position.
+     */
+    planarFastPathApplies(lat_rad: number, lon_rad: number, height_m: number): boolean;
+    /**
+     * Number of polygon edges.
+     */
+    readonly edgeCount: number;
+    /**
+     * Fence vertices in open-polygon form as flat `[latRad, lonRad, heightM]` rows.
+     */
+    readonly vertices: Float64Array;
+}
+
+/**
+ * Geofence crossing event direction.
+ */
+export enum GeofenceCrossingKind {
+    /**
+     * The sample sequence entered the fence.
+     */
+    Entered = 0,
+    /**
+     * The sample sequence left the fence.
+     */
+    Left = 1,
+}
+
+/**
+ * Geofence construction and evaluation error variants.
+ */
+export enum GeofenceError {
+    /**
+     * Fewer than three distinct vertices were supplied.
+     */
+    TooFewVertices = 0,
+    /**
+     * A geofence input value was outside its domain.
+     */
+    InvalidInput = 1,
+    /**
+     * The geodesic direct or inverse calculation failed.
+     */
+    Geodesic = 2,
+    /**
+     * ECEF covariance rotation failed.
+     */
+    Dop = 3,
+    /**
+     * Covariance or radius validation failed.
+     */
+    ErrorMetrics = 4,
+}
+
+/**
+ * Probability integration method for geofence uncertainty.
+ */
+export enum GeofenceProbabilityMethod {
+    /**
+     * Gaussian half-space approximation from boundary distance and normal variance.
+     */
+    BoundaryNormal = 0,
+    /**
+     * Fixed quadrature over the local planarized fence.
+     */
+    PlanarQuadrature = 1,
+}
+
 /**
  * A regular latitude/longitude grid of geoid undulation samples with bilinear
  * interpolation, wrapping a real (loaded) geoid model.
@@ -2132,6 +2321,78 @@ export class GlonassRecordJs {
     readonly velocityMS: Float64Array;
 }
 
+/**
+ * Stateful GNSS/INS filter resource.
+ */
+export class GnssInsFilter {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Replace retained-history capacities for later time-sync replay.
+     */
+    configureTimeSync(config: any): void;
+    /**
+     * Encode the current fusion state with the core versioned binary codec.
+     */
+    encodeState(): Uint8Array;
+    /**
+     * Build a filter, then restore its state from versioned fusion-state bytes.
+     */
+    static fromStateBytes(config: any, bytes: Uint8Array): GnssInsFilter;
+    /**
+     * Build a filter from a JS configuration object.
+     */
+    constructor(config: any);
+    /**
+     * Propagate the filter with one IMU rate or increment sample.
+     */
+    propagate(sample: any): any;
+    /**
+     * Propagate the filter with a JS array of IMU samples.
+     */
+    propagateBatch(samples: any): any;
+    /**
+     * Restore this filter from versioned fusion-state bytes.
+     */
+    restoreState(bytes: Uint8Array): void;
+    /**
+     * Current INS state, covariance, and last body-rate diagnostic.
+     */
+    state(): any;
+    /**
+     * Current tight-coupling receiver-clock state.
+     */
+    tightClockState(): any;
+    /**
+     * Current retained-history capacity and occupancy.
+     */
+    timeSyncStatus(): any;
+    /**
+     * Apply a loose position or position-velocity GNSS fix at the current epoch.
+     */
+    updateLoose(measurement: any): any;
+    /**
+     * Apply a loose GNSS fix, replaying retained IMU checkpoints when it is late.
+     */
+    updateLooseTimeSync(measurement: any): any;
+    /**
+     * Apply a tight raw-observation epoch against a broadcast ephemeris source.
+     */
+    updateTightBroadcast(broadcast: BroadcastEphemeris, epoch: any): any;
+    /**
+     * Apply a tight broadcast update, replaying retained IMU checkpoints when it is late.
+     */
+    updateTightBroadcastTimeSync(broadcast: BroadcastEphemeris, epoch: any): any;
+    /**
+     * Apply a tight raw-observation epoch against an SP3 source.
+     */
+    updateTightSp3(sp3: Sp3, epoch: any): any;
+    /**
+     * Apply a tight SP3 update, replaying retained IMU checkpoints when it is late.
+     */
+    updateTightSp3TimeSync(sp3: Sp3, epoch: any): any;
+}
+
 /**
  * One sampled rise/set/peak visibility pass, from `gnssPasses`.
  */
@@ -4760,6 +5021,73 @@ export class PreciseEphemerisSampleSource {
     readonly satellites: string[];
 }
 
+/**
+ * Evaluable precise-interpolant artifact opened from canonical store bytes.
+ */
+export class PreciseInterpolantArtifact {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Evaluate one satellite state at a J2000-second epoch.
+     */
+    evaluate(satellite: string, j2000_seconds: number): Sp3State;
+    /**
+     * Number of bytes retained by this artifact handle.
+     */
+    readonly byteLength: number;
+    /**
+     * File-level artifact checksum.
+     */
+    readonly checksum64: bigint;
+    /**
+     * Satellite tokens present in the artifact, ascending.
+     */
+    readonly satellites: string[];
+    /**
+     * Artifact time scale label from the stored epoch axis.
+     */
+    readonly timeScale: string;
+}
+
+/**
+ * Error category for precise-interpolant artifact open or serialization.
+ */
+export enum PreciseInterpolantArtifactError {
+    /**
+     * File I/O failed in the core artifact API.
+     */
+    Io = 0,
+    /**
+     * Artifact bytes could not be parsed.
+     */
+    Parse = 1,
+    /**
+     * The artifact version tag is unsupported.
+     */
+    UnsupportedVersion = 2,
+    /**
+     * The artifact time-scale tag is unsupported.
+     */
+    UnsupportedTimeScale = 3,
+    /**
+     * A satellite-system tag is unsupported.
+     */
+    UnsupportedSatelliteSystem = 4,
+    /**
+     * A satellite appears more than once in the artifact index.
+     */
+    DuplicateSatellite = 5,
+    /**
+     * The artifact file-level checksum did not match.
+     */
+    Checksum = 6,
+    /**
+     * A satellite payload checksum did not match its index record.
+     */
+    SatelliteChecksum = 7,
+}
+
 /**
  * The per-request results of a batch observable prediction, index-aligned to
  * the input requests. Each request independently either produced observables or
@@ -5567,6 +5895,87 @@ export class SbasSisError {
     readonly sigmaUireM: number;
 }
 
+/**
+ * Stable GNSS signal modulation used by the analysis functions.
+ */
+export class SignalAnalysisModulation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Normalized in-band autocorrelation at a delay.
+     */
+    autocorrelation(delay_s: number, receiver_bandwidth_hz: number): number;
+    /**
+     * Build a BPSK(n) modulation, where the code rate is `n * 1.023 MHz`.
+     */
+    static bpsk(order: number): SignalAnalysisModulation;
+    /**
+     * Build Galileo E1 CBOC(6,1,1/11) with the minus chip-pulse convention.
+     */
+    static cboc611Over11Minus(): SignalAnalysisModulation;
+    /**
+     * Build Galileo E1 CBOC(6,1,1/11) with the plus chip-pulse convention.
+     */
+    static cboc611Over11Plus(): SignalAnalysisModulation;
+    /**
+     * Build a cosine-phased BOC(m,n) modulation.
+     */
+    static cosineBoc(m: number, n: number): SignalAnalysisModulation;
+    /**
+     * Published lower bound for DLL code-delay jitter.
+     */
+    dllLowerBound(options: any): any;
+    /**
+     * Early-late DLL thermal-noise jitter for this modulation.
+     */
+    dllThermalNoiseJitter(options: any, processing: DllProcessing): any;
+    /**
+     * Fraction of total signal power inside a two-sided receiver bandwidth.
+     */
+    fractionPowerInBand(receiver_bandwidth_hz: number): number;
+    /**
+     * Build the normalized MBOC(6,1,1/11) spectrum.
+     */
+    static mboc611Over11(): SignalAnalysisModulation;
+    /**
+     * One-path early-late multipath error envelope on a delay grid.
+     */
+    multipathErrorEnvelope(options: any, delay_chips: Float64Array): any;
+    /**
+     * Signal power inside a two-sided receiver bandwidth.
+     */
+    powerInBand(receiver_bandwidth_hz: number): number;
+    /**
+     * Normalized power spectral density at an offset frequency, in `1/Hz`.
+     */
+    psdHz(offset_hz: number): number;
+    /**
+     * RMS, or Gabor, bandwidth over a two-sided receiver bandwidth.
+     */
+    rmsBandwidthHz(receiver_bandwidth_hz: number): number;
+    /**
+     * Build a sine-phased BOC(m,n) modulation.
+     */
+    static sineBoc(m: number, n: number): SignalAnalysisModulation;
+    /**
+     * Build the GPS L1C pilot TMBOC(6,1,4/33) spectrum.
+     */
+    static tmboc614Over33(): SignalAnalysisModulation;
+    /**
+     * SSC against white interference normalized over the receiver bandwidth.
+     */
+    whiteNoiseSpectralSeparationHz(receiver_bandwidth_hz: number): number;
+    /**
+     * Code rate in hertz when the modulation has one unambiguous rate.
+     */
+    readonly codeRateHz: number;
+    /**
+     * Stable core label for this modulation.
+     */
+    readonly label: string;
+}
+
 /**
  * Per-constellation single-frequency pseudorange code-selection policy. Build
  * with `new SignalPolicy()` then chain `.withSystem(system, codes)`, or use
@@ -5721,6 +6130,21 @@ export class Sp3 {
      * TypeScript type. Returns the corrected solution and the base baseline.
      */
     dgnssSolve(request: any): DgnssSolution;
+    /**
+     * Evaluate emission-time state and media corrections for index-aligned satellites.
+     *
+     * `satellites` and `emissionEpochsJ2000S` share a row count. `receiverEcefM`
+     * is `[x, y, z]` metres. Without an IONEX product this can still request
+     * troposphere corrections by passing `{ troposphere: true }`.
+     */
+    emissionMediaBatch(satellites: string[], emission_epochs_j2000_s: Float64Array, receiver_ecef_m: Float64Array, options: any): EmissionMediaBatch;
+    /**
+     * Evaluate emission-time state plus IONEX/troposphere media corrections.
+     *
+     * `options.ionosphere` defaults to `true` on this IONEX-bearing path.
+     * `options.troposphere` defaults to `false`.
+     */
+    emissionMediaBatchIonex(ionex: Ionex, satellites: string[], emission_epochs_j2000_s: Float64Array, receiver_ecef_m: Float64Array, options: any): EmissionMediaBatch;
     /**
      * The product's parsed epochs as seconds since J2000 (the product's own
      * time scale), ascending. This is the exact axis [`Sp3.interpolate`]
@@ -5766,6 +6190,10 @@ export class Sp3 {
      * [`observableStatesAtJ2000S`](Self::observable_states_at_j2000_s).
      */
     observableStatesAtSharedJ2000S(satellites: any, epoch_j2000_s: number): any;
+    /**
+     * Build deterministic precise-interpolant artifact bytes from this SP3 product.
+     */
+    preciseInterpolantArtifactBytes(): Uint8Array;
     /**
      * Predict geometric ranges for many `(satellite, receiver, epoch)` requests
      * against this ephemeris in one call. `requests` is an array of
@@ -5793,6 +6221,22 @@ export class Sp3 {
      * or failed. Delegates to the serial reference batch kernel.
      */
     solveSppBatch(epochs: any, options: any): SppBatchSolution;
+    /**
+     * Run SPP and attach a Doppler velocity/clock-drift solve when Doppler rows solve.
+     *
+     * `request` is the normal SPP request object. `dopplerObservations` is an
+     * array of `{ satelliteId, dopplerHz, carrierHz, satClockDriftSS? }`. The
+     * returned receiver solution carries `rxClockDriftSS` when velocity solved.
+     */
+    solveSppWithDopplerVelocity(request: any, doppler_observations: any): SppDopplerSolution;
+    /**
+     * Solve one static receiver position from multiple SPP-shaped epochs.
+     *
+     * `epochs` is an array of SPP request objects. `options` accepts
+     * `{ initialPositionM?, withGeodetic?, robust? }` and returns shared
+     * position, per-epoch clocks, covariance, residual, and influence surfaces.
+     */
+    solveStatic(epochs: any, options: any): StaticSolution;
     /**
      * Run the core robust-reweighted SPP driver under the RAIM/FDE exclusion loop.
      *
@@ -6248,6 +6692,27 @@ export class SppBatchSolution {
     readonly count: number;
 }
 
+/**
+ * Position solution with an optional Doppler velocity solve.
+ */
+export class SppDopplerSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Receiver position, clock, and covariance solution.
+     */
+    readonly receiver: SppSolution;
+    /**
+     * Doppler-derived receiver velocity and clock drift, if the velocity rows solved.
+     */
+    readonly velocity: VelocitySolution | undefined;
+    /**
+     * Velocity-solve failure text when Doppler rows were present but unusable.
+     */
+    readonly velocityError: string | undefined;
+}
+
 /**
  * The result of an SPP solve.
  */
@@ -6273,6 +6738,14 @@ export class SppSolution {
      * are returned as a singular-geometry `Error` rather than a solution.
      */
     readonly geometryQuality: GeometryQuality;
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEcefM2: Float64Array;
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEnuM2: Float64Array;
     /**
      * ECEF position as a `Float64Array` `[x, y, z]`, metres.
      */
@@ -6289,6 +6762,10 @@ export class SppSolution {
      * Post-fit residuals, metres, index-aligned to `usedSats`.
      */
     readonly residualsM: Float64Array;
+    /**
+     * Receiver clock drift in seconds per second when a Doppler solve was fused.
+     */
+    readonly rxClockDriftSS: number | undefined;
     /**
      * Receiver clock bias, seconds.
      */
@@ -6342,6 +6819,121 @@ export enum SsrSource {
     GalileoHas = 1,
 }
 
+/**
+ * Status for a leave-one-out static positioning diagnostic.
+ */
+export enum StaticInfluenceStatus {
+    /**
+     * The diagnostic solve completed.
+     */
+    Solved = 0,
+    /**
+     * The omitted subset left too few measurements.
+     */
+    TooFewMeasurements = 1,
+    /**
+     * The diagnostic geometry was singular.
+     */
+    SingularGeometry = 2,
+    /**
+     * Input validation failed for the diagnostic subset.
+     */
+    InvalidInput = 3,
+    /**
+     * Ephemeris was unavailable for the diagnostic subset.
+     */
+    EphemerisUnavailable = 4,
+    /**
+     * The diagnostic subset failed for another reason.
+     */
+    SolveFailed = 5,
+}
+
+/**
+ * Multi-epoch static receiver solution.
+ */
+export class StaticSolution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * `[latRad, lonRad, heightM]` when geodetic output was requested.
+     */
+    readonly geodetic: Float64Array | undefined;
+    /**
+     * Geometry observability and covariance-validation diagnostics.
+     */
+    readonly geometryQuality: GeometryQuality;
+    /**
+     * Solver iteration, convergence, and redundancy metadata.
+     */
+    readonly metadata: any;
+    /**
+     * Epoch-local receiver clocks as `{ epochIndex, system, clockS }[]`.
+     */
+    readonly perEpochClocks: any;
+    /**
+     * Leave-one-epoch-out diagnostics.
+     */
+    readonly perEpochInfluence: any;
+    /**
+     * Leave-one-satellite-out diagnostics across every epoch.
+     */
+    readonly perSatelliteBatchInfluence: any;
+    /**
+     * Leave-one-satellite-out diagnostics per epoch.
+     */
+    readonly perSatelliteInfluence: any;
+    /**
+     * ECEF position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEcefM2: Float64Array;
+    /**
+     * ENU position covariance, flat row-major 3-by-3 in square metres.
+     */
+    readonly positionCovarianceEnuM2: Float64Array;
+    /**
+     * ECEF position as `[x, y, z]`, metres.
+     */
+    readonly positionM: Float64Array;
+    /**
+     * Rejected satellites grouped by input epoch.
+     */
+    readonly rejectedSats: any;
+    /**
+     * Root-mean-square of the unweighted post-fit residuals, metres.
+     */
+    readonly residualRmsM: number;
+    /**
+     * Post-fit residuals as `{ epochIndex, satelliteId, residualM, ... }[]`.
+     */
+    readonly residuals: any;
+    /**
+     * Full state covariance, flat row-major square matrix in square metres.
+     */
+    readonly stateCovarianceM2: Float64Array;
+    /**
+     * State covariance matrix dimension.
+     */
+    readonly stateParameterCount: number;
+    /**
+     * Used satellite tokens grouped by input epoch.
+     */
+    readonly usedSats: any;
+    /**
+     * ECEF X, metres.
+     */
+    readonly xM: number;
+    /**
+     * ECEF Y, metres.
+     */
+    readonly yM: number;
+    /**
+     * ECEF Z, metres.
+     */
+    readonly zM: number;
+}
+
 /**
  * A batch of Sun and Moon positions, one per epoch: flat row-major `sun` and
  * `moon` `Float64Array`s of length `3 * epochCount`, in **metres**.
@@ -7033,6 +7625,10 @@ export class VelocitySolution {
      * Receiver speed, metres per second.
      */
     readonly speedMS: number;
+    /**
+     * Unit-variance covariance of `[vx, vy, vz, clockDrift]`, flat row-major.
+     */
+    readonly stateCovariance: Float64Array;
     /**
      * Satellite tokens contributing rows, in residual order.
      */
@@ -7549,6 +8145,11 @@ export function decodeSsr(bytes: Uint8Array, framed?: boolean | null): any;
  */
 export function defaultPair(system: GnssSystem): CarrierPair | undefined;
 
+/**
+ * Default scenario seed as a hexadecimal string.
+ */
+export function defaultScenarioSeedHex(): string;
+
 /**
  * Single-frequency carrier used by the SPP ionosphere-scaling policy.
  */
@@ -7663,6 +8264,11 @@ export function ecefToGeodetic(position_km: Float64Array): Float64Array;
  */
 export function eclipseStatus(satellite_position_km: Float64Array, sun_position_km: Float64Array): string[];
 
+/**
+ * Effective C/N0 degradation for one finite-band interference term.
+ */
+export function effectiveCn0Degradation(desired: SignalAnalysisModulation, interference: SignalAnalysisModulation, cn0_db_hz: number, receiver_bandwidth_hz: number, power_ratio_to_carrier: number): any;
+
 /**
  * Ellipsoidal height `h = H + N` (metres above the WGS84 ellipsoid) from an
  * orthometric height and a geodetic position in radians, using the embedded
@@ -7713,6 +8319,11 @@ export function eirp(tx_power_dbm: number, tx_antenna_gain_dbi: number): number;
  */
 export function ellipsoidalHeightM(orthometric_height_m: number, lat_rad: number, lon_rad: number): number;
 
+/**
+ * Stable string label for an [`EmissionMediaStatus`] enum value.
+ */
+export function emissionMediaStatusLabel(status: EmissionMediaStatus): string;
+
 /**
  * Encode plain RINEX observation text into a Compact RINEX (Hatanaka) stream,
  * the inverse of [`decodeCrinex`]. RINEX 2 is emitted as CRINEX 1.0 and RINEX 3
@@ -8064,6 +8675,11 @@ export function fromCelestrakJsonLenient(json: string, system?: string | null):
  */
 export function fspl(distance_km: number, frequency_mhz: number): number;
 
+/**
+ * Decode and re-encode fusion-state bytes through the core codec.
+ */
+export function fusionStateBytesRoundTrip(bytes: Uint8Array): Uint8Array;
+
 /**
  * Galileo NeQuick-G single-frequency ionospheric group delay (positive metres).
  *
@@ -8124,6 +8740,49 @@ export function geodesicInverse(lat1_deg: number, lon1_deg: number, lat2_deg: nu
  */
 export function geodeticToEcef(geodetic: Float64Array): Float64Array;
 
+/**
+ * Containment probability using default probability options.
+ */
+export function geofenceContainmentProbability(vertices: Float64Array, lat_rad: number, lon_rad: number, height_m: number, uncertainty_value: any): number;
+
+/**
+ * Boolean containment for one position and flat vertex array.
+ */
+export function geofenceContains(vertices: Float64Array, lat_rad: number, lon_rad: number, height_m: number): boolean;
+
+/**
+ * Stable string label for a [`GeofenceCrossingKind`] enum value.
+ */
+export function geofenceCrossingKindLabel(kind: GeofenceCrossingKind): string;
+
+/**
+ * Probabilistic crossing detection with default hysteresis.
+ */
+export function geofenceCrossingProbability(vertices: Float64Array, samples: any, options: any): any;
+
+/**
+ * Stable string label for a [`GeofenceError`] enum value.
+ */
+export function geofenceErrorLabel(error: GeofenceError): string;
+
+/**
+ * Construct a geodesic WGS84 polygon from flat 2D radian vertices.
+ */
+export function geofenceFromVertices(vertices: Float64Array): Geofence;
+
+/**
+ * Construct a geodesic WGS84 polygon from flat 3D radian vertices.
+ *
+ * `vertices` is `[latRad, lonRad, heightM, ...]`. Heights are accepted but
+ * ignored by the core geofence model.
+ */
+export function geofenceFromVertices3d(vertices: Float64Array): Geofence;
+
+/**
+ * Stable string label for a [`GeofenceProbabilityMethod`] enum value.
+ */
+export function geofenceProbabilityMethodLabel(method: GeofenceProbabilityMethod): string;
+
 /**
  * Geoid undulation `N` (metres above the WGS84 ellipsoid) at a geodetic
  * position in radians, from the COARSE built-in global grid. Latitude is
@@ -8909,6 +9568,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;
 
+/**
+ * Open precise-interpolant artifact bytes as an evaluable in-memory product.
+ *
+ * The returned handle owns its byte buffer because JS byte slices cannot be
+ * borrowed across calls by this class boundary.
+ */
+export function openPreciseInterpolantArtifact(bytes: Uint8Array): PreciseInterpolantArtifact;
+
 /**
  * Broadcast-derived per-satellite orbit-repeat lag, in seconds.
  *
@@ -9139,6 +9806,16 @@ export function pppCorrectionsWithCodeBias(sp3: Sp3, epochs: any, receiver_ecef_
  */
 export function preciseEphemerisSamplesFromSamples(samples: any): PreciseEphemerisSampleSource;
 
+/**
+ * Compute the precise-interpolant artifact file-level checksum for byte content.
+ */
+export function preciseInterpolantArtifactChecksum64(bytes: Uint8Array): bigint;
+
+/**
+ * Stable string label for a [`PreciseInterpolantArtifactError`] enum value.
+ */
+export function preciseInterpolantArtifactErrorLabel(error: PreciseInterpolantArtifactError): string;
+
 /**
  * Predict observables for many `(satellite, receiver, epoch)` requests from a
  * broadcast ephemeris store, serially. See [`predictBatchSp3`] for the argument
@@ -9407,6 +10084,16 @@ export function sbasPrnToSat(broadcast_prn: number): any;
  */
 export function sbasProtectionLevels(geometry: any, model: SbasErrorModel, k: SbasKMultipliers): SbasProtection;
 
+/**
+ * Core scenario engine version string used in deterministic outputs.
+ */
+export function scenarioEngineVersion(): string;
+
+/**
+ * Core scenario schema version accepted by the binding.
+ */
+export function scenarioSchemaVersion(): number;
+
 /**
  * Screen a primary satellite against a secondary TLE catalog for threshold TCAs.
  *
@@ -9503,6 +10190,26 @@ export function siderealFilter(series: any, period_s: number, options: any): any
  */
 export function sigmas(entries: any, options: any): SatelliteVector;
 
+/**
+ * Simulate a scenario from a JS object or JSON string and return JS arrays.
+ */
+export function simulateScenario(value: any): any;
+
+/**
+ * Simulate a scenario from a JS object or JSON string and return deterministic JSON bytes.
+ */
+export function simulateScenarioBytes(value: any): Uint8Array;
+
+/**
+ * Simulate a scenario from JSON text and return JS arrays.
+ */
+export function simulateScenarioJson(text: string): any;
+
+/**
+ * Simulate a scenario from JSON text and return deterministic JSON bytes.
+ */
+export function simulateScenarioJsonBytes(text: string): Uint8Array;
+
 /**
  * Sample skewness of a residual set.
  *
@@ -9649,6 +10356,11 @@ export function solveRtkFloat(config: any): RtkFloatSolution;
  */
 export function solveSppSbas(broadcast: BroadcastEphemeris, store: SbasCorrectionStore, geo: string, request: any, mode?: string | null): SppSolution;
 
+/**
+ * Solve one static receiver position from multiple SPP-shaped epochs over SP3.
+ */
+export function solveStatic(sp3: Sp3, epochs: any, options: any): StaticSolution;
+
 /**
  * Solve a static RTK arc with one batch float solution and one validated fixed
  * solution over the whole arc.
@@ -9727,6 +10439,16 @@ export function sourceSolveModeToa(): string;
  */
 export function sp3PreciseEphemerisSamples(sp3: Sp3): any;
 
+/**
+ * Spectral separation coefficient between two modulations, in dB-Hz.
+ */
+export function spectralSeparationCoefficientDbHz(desired: SignalAnalysisModulation, interference: SignalAnalysisModulation, receiver_bandwidth_hz: number): number;
+
+/**
+ * Spectral separation coefficient between two modulations, in hertz.
+ */
+export function spectralSeparationCoefficientHz(desired: SignalAnalysisModulation, interference: SignalAnalysisModulation, receiver_bandwidth_hz: number): number;
+
 /**
  * Continuous seconds since J2000 for a split Julian date.
  */
@@ -9739,6 +10461,11 @@ export function ssrCorrectedState(broadcast: BroadcastEphemeris, store: SsrCorre
  */
 export function ssrSourceLabel(source: SsrSource): string;
 
+/**
+ * Stable string label for a [`StaticInfluenceStatus`] enum value.
+ */
+export function staticInfluenceStatusLabel(status: StaticInfluenceStatus): string;
+
 /**
  * Sub-observer point (planetary central meridian) on a rotating body.
  *