@justinelliottcobb/amari-wasm 0.9.0 → 0.9.2

package/amari_wasm.d.ts

@@ -1,5 +1,21 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Convert Lorentz factor to velocity
+ */
+export function gamma_to_velocity(gamma: number): number;
+/**
+ * Convert velocity to Lorentz factor
+ */
+export function velocity_to_gamma(velocity_magnitude: number): number;
+/**
+ * Calculate light deflection angle for photon grazing massive object
+ */
+export function light_deflection_angle(impact_parameter: number, mass: number): number;
+/**
+ * Validate that this module loaded correctly
+ */
+export function validate_relativistic_module(): boolean;
 /**
  * Initialize the WASM module
  */
@@ -21,6 +37,22 @@ export class BatchOperations {
    */
   static batchAdd(a_batch: Float64Array, b_batch: Float64Array): Float64Array;
 }
+/**
+ * Batch network operations for performance
+ */
+export class NetworkBatchOperations {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Fast geometric clustering using k-means in 3D space
+   */
+  static geometricKMeansClustering(positions: Float64Array, num_nodes: number, k: number, max_iterations: number): Uint32Array;
+  /**
+   * Compute all pairwise distances in a network
+   */
+  static computeAllPairwiseDistances(positions: Float64Array, num_nodes: number): Float64Array;
+}
 /**
  * High-performance WASM operations with memory pooling
  */
@@ -29,60 +61,153 @@ export class PerformanceOperations {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Fast geometric product for hot paths with memory pooling
+   * Batch normalize vectors for efficiency
    */
-  static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
+  static batchNormalize(vectors: Float64Array, vector_size: number): Float64Array;
+  /**
+   * Optimized vector dot product
+   */
+  static vectorDotProduct(v1: Float64Array, v2: Float64Array): number;
   /**
    * Optimized vector operations for 3D space
    */
   static vectorCrossProduct(v1: Float64Array, v2: Float64Array): Float64Array;
   /**
-   * Optimized vector dot product
+   * Fast geometric product for hot paths with memory pooling
    */
-  static vectorDotProduct(v1: Float64Array, v2: Float64Array): number;
+  static fastGeometricProduct(lhs: Float64Array, rhs: Float64Array): Float64Array;
+}
+/**
+ * WASM wrapper for four-velocity
+ */
+export class WasmFourVelocity {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
   /**
-   * Batch normalize vectors for efficiency
+   * Create four-velocity from 3-velocity components
    */
-  static batchNormalize(vectors: Float64Array, vector_size: number): Float64Array;
+  static from_velocity(vx: number, vy: number, vz: number): WasmFourVelocity;
+  /**
+   * Check if normalized (u·u = c²)
+   */
+  is_normalized(): boolean;
+  /**
+   * Get as spacetime vector
+   */
+  as_spacetime_vector(): WasmSpacetimeVector;
+  /**
+   * Get spatial velocity magnitude
+   */
+  spatial_velocity_magnitude(): number;
+  /**
+   * Get Lorentz factor γ
+   */
+  gamma(): number;
+  /**
+   * Get rapidity
+   */
+  rapidity(): number;
+  /**
+   * Get string representation
+   */
+  to_string(): string;
 }
 /**
- * WASM wrapper for Multivector with TypedArray support
+ * WASM wrapper for geodesic integration
  */
-export class WasmMultivector {
+export class WasmGeodesicIntegrator {
+  private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Create a new zero multivector
+   * Propagate particle through spacetime
    */
-  constructor();
+  propagate_particle(particle: WasmRelativisticParticle, integration_time: number, time_step: number): Array<any>;
   /**
-   * Create from a Float64Array of coefficients
+   * Create integrator with Schwarzschild metric
    */
-  static fromCoefficients(coefficients: Float64Array): WasmMultivector;
+  static with_schwarzschild(metric: WasmSchwarzschildMetric): WasmGeodesicIntegrator;
+}
+/**
+ * WASM wrapper for GeometricNetwork
+ */
+export class WasmGeometricNetwork {
+  free(): void;
+  [Symbol.dispose](): void;
   /**
-   * Create a scalar multivector
+   * Get degree of a node
    */
-  static scalar(value: number): WasmMultivector;
+  getDegree(node: number): number;
   /**
-   * Create a basis vector (0-indexed)
+   * Get neighbors of a node
    */
-  static basisVector(index: number): WasmMultivector;
+  getNeighbors(node: number): Uint32Array;
   /**
-   * Get coefficients as a Float64Array
+   * Find shortest path between two nodes
+   * Returns the path as an array of node indices, or null if no path exists
    */
-  getCoefficients(): Float64Array;
+  shortestPath(source: number, target: number): Uint32Array | undefined;
   /**
-   * Get a specific coefficient
+   * Add a labeled node
    */
-  getCoefficient(index: number): number;
+  addLabeledNode(x: number, y: number, z: number, label: string): number;
   /**
-   * Set a specific coefficient
+   * Find communities using geometric clustering
    */
-  setCoefficient(index: number, value: number): void;
+  findCommunities(num_communities: number): Uint32Array;
   /**
-   * Geometric product
+   * Get node position as [x, y, z]
    */
-  geometricProduct(other: WasmMultivector): WasmMultivector;
+  getNodePosition(node: number): Float64Array | undefined;
+  /**
+   * Compute geometric distance between two nodes
+   */
+  geometricDistance(node1: number, node2: number): number;
+  /**
+   * Add an undirected edge
+   */
+  addUndirectedEdge(a: number, b: number, weight: number): void;
+  /**
+   * Find shortest path with distance between two nodes
+   * Returns an object with path and distance, or null if no path exists
+   */
+  shortestPathWithDistance(source: number, target: number): any;
+  /**
+   * Compute geometric centrality for all nodes
+   */
+  computeGeometricCentrality(): Float64Array;
+  /**
+   * Create a new geometric network
+   */
+  constructor();
+  /**
+   * Add an edge between two nodes
+   */
+  addEdge(source: number, target: number, weight: number): void;
+  /**
+   * Add a node at the given position
+   */
+  addNode(x: number, y: number, z: number): number;
+  /**
+   * Get number of edges
+   */
+  numEdges(): number;
+  /**
+   * Get number of nodes
+   */
+  numNodes(): number;
+}
+/**
+ * WASM wrapper for Multivector with TypedArray support
+ */
+export class WasmMultivector {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a basis vector (0-indexed)
+   */
+  static basisVector(index: number): WasmMultivector;
   /**
    * Inner product (dot product for vectors)
    */
@@ -96,45 +221,148 @@ export class WasmMultivector {
    */
   scalarProduct(other: WasmMultivector): number;
   /**
-   * Reverse
+   * Get a specific coefficient
    */
-  reverse(): WasmMultivector;
+  getCoefficient(index: number): number;
+  /**
+   * Set a specific coefficient
+   */
+  setCoefficient(index: number, value: number): void;
+  /**
+   * Get coefficients as a Float64Array
+   */
+  getCoefficients(): Float64Array;
   /**
    * Grade projection
    */
   gradeProjection(grade: number): WasmMultivector;
+  /**
+   * Create from a Float64Array of coefficients
+   */
+  static fromCoefficients(coefficients: Float64Array): WasmMultivector;
+  /**
+   * Geometric product
+   */
+  geometricProduct(other: WasmMultivector): WasmMultivector;
+  /**
+   * Add two multivectors
+   */
+  add(other: WasmMultivector): WasmMultivector;
   /**
    * Exponential (for bivectors to create rotors)
    */
   exp(): WasmMultivector;
   /**
-   * Compute magnitude
+   * Create a new zero multivector
    */
-  magnitude(): number;
+  constructor();
+  /**
+   * Subtract two multivectors
+   */
+  sub(other: WasmMultivector): WasmMultivector;
   /**
    * Compute norm (alias for magnitude, maintained for compatibility)
    */
   norm(): number;
   /**
-   * Normalize
+   * Scale by a scalar
    */
-  normalize(): WasmMultivector;
+  scale(scalar: number): WasmMultivector;
+  /**
+   * Create a scalar multivector
+   */
+  static scalar(value: number): WasmMultivector;
   /**
    * Compute inverse
    */
   inverse(): WasmMultivector;
   /**
-   * Add two multivectors
+   * Reverse
    */
-  add(other: WasmMultivector): WasmMultivector;
+  reverse(): WasmMultivector;
   /**
-   * Subtract two multivectors
+   * Compute magnitude
    */
-  sub(other: WasmMultivector): WasmMultivector;
+  magnitude(): number;
   /**
-   * Scale by a scalar
+   * Normalize
    */
-  scale(scalar: number): WasmMultivector;
+  normalize(): WasmMultivector;
+}
+/**
+ * Physical constants
+ */
+export class WasmRelativisticConstants {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Earth mass (kg)
+   */
+  static readonly earth_mass: number;
+  /**
+   * Solar mass (kg)
+   */
+  static readonly solar_mass: number;
+  /**
+   * Speed of light in vacuum (m/s)
+   */
+  static readonly speed_of_light: number;
+  /**
+   * Gravitational constant (m³/kg·s²)
+   */
+  static readonly gravitational_constant: number;
+}
+/**
+ * WASM wrapper for relativistic particles
+ */
+export class WasmRelativisticParticle {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get 3D position components
+   */
+  position_3d(): Array<any>;
+  /**
+   * Get position as spacetime vector
+   */
+  position_4d(): WasmSpacetimeVector;
+  /**
+   * Create particle with specified energy
+   */
+  static with_energy(x: number, y: number, z: number, direction_x: number, direction_y: number, direction_z: number, kinetic_energy: number, mass: number, charge: number): WasmRelativisticParticle;
+  /**
+   * Get total energy
+   */
+  total_energy(): number;
+  /**
+   * Get four-velocity
+   */
+  four_velocity(): WasmFourVelocity;
+  /**
+   * Get kinetic energy
+   */
+  kinetic_energy(): number;
+  /**
+   * Get momentum magnitude
+   */
+  momentum_magnitude(): number;
+  /**
+   * Create a new relativistic particle
+   */
+  constructor(x: number, y: number, z: number, vx: number, vy: number, vz: number, spin: number, mass: number, charge: number);
+  /**
+   * Get rest mass
+   */
+  mass(): number;
+  /**
+   * Get electric charge
+   */
+  charge(): number;
+  /**
+   * Get string representation
+   */
+  to_string(): string;
 }
 /**
  * Rotor operations for WASM
@@ -160,49 +388,240 @@ export class WasmRotor {
    */
   inverse(): WasmRotor;
 }
+/**
+ * WASM wrapper for Schwarzschild metric
+ */
+export class WasmSchwarzschildMetric {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check for singularity at given position
+   */
+  has_singularity(position: WasmSpacetimeVector): boolean;
+  /**
+   * Compute effective potential for circular orbits
+   */
+  effective_potential(r: number, angular_momentum: number): number;
+  /**
+   * Get Schwarzschild radius
+   */
+  schwarzschild_radius(): number;
+  /**
+   * Create Schwarzschild metric for the Sun
+   */
+  static sun(): WasmSchwarzschildMetric;
+  /**
+   * Get central mass
+   */
+  mass(): number;
+  /**
+   * Create Schwarzschild metric for Earth
+   */
+  static earth(): WasmSchwarzschildMetric;
+  /**
+   * Create Schwarzschild metric for custom mass
+   */
+  static from_mass(mass: number): WasmSchwarzschildMetric;
+}
+/**
+ * WASM wrapper for spacetime vectors
+ */
+export class WasmSpacetimeVector {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if vector is timelike (massive particle)
+   */
+  is_timelike(): boolean;
+  /**
+   * Check if vector is spacelike
+   */
+  is_spacelike(): boolean;
+  /**
+   * Compute Minkowski norm squared
+   */
+  norm_squared(): number;
+  /**
+   * Compute Minkowski inner product with another spacetime vector
+   */
+  minkowski_dot(other: WasmSpacetimeVector): number;
+  /**
+   * Create a new spacetime vector with components (ct, x, y, z)
+   */
+  constructor(t: number, x: number, y: number, z: number);
+  /**
+   * Check if vector is null (lightlike)
+   */
+  is_null(): boolean;
+  /**
+   * Create a timelike vector
+   */
+  static timelike(t: number): WasmSpacetimeVector;
+  /**
+   * Create a spacelike vector
+   */
+  static spacelike(x: number, y: number, z: number): WasmSpacetimeVector;
+  /**
+   * Get string representation
+   */
+  to_string(): string;
+  /**
+   * Get temporal component
+   */
+  readonly t: number;
+  /**
+   * Get x component
+   */
+  readonly x: number;
+  /**
+   * Get y component
+   */
+  readonly y: number;
+  /**
+   * Get z component
+   */
+  readonly z: number;
+}
+/**
+ * Trajectory point for particle propagation
+ */
+export class WasmTrajectoryPoint {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get position
+   */
+  readonly position: WasmSpacetimeVector;
+  /**
+   * Time coordinate
+   */
+  time: number;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_batchoperations_free: (a: number, b: number) => void;
+  readonly __wbg_get_wasmtrajectorypoint_time: (a: number) => number;
+  readonly __wbg_set_wasmtrajectorypoint_time: (a: number, b: number) => void;
+  readonly __wbg_wasmfourvelocity_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgeodesicintegrator_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgeometricnetwork_free: (a: number, b: number) => void;
   readonly __wbg_wasmmultivector_free: (a: number, b: number) => void;
-  readonly wasmmultivector_new: () => number;
-  readonly wasmmultivector_fromCoefficients: (a: number, b: number) => [number, number, number];
-  readonly wasmmultivector_scalar: (a: number) => number;
+  readonly __wbg_wasmrelativisticparticle_free: (a: number, b: number) => void;
+  readonly __wbg_wasmschwarzschildmetric_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtrajectorypoint_free: (a: number, b: number) => void;
+  readonly batchoperations_batchAdd: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly batchoperations_batchGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+  readonly gamma_to_velocity: (a: number) => [number, number, number];
+  readonly init: () => void;
+  readonly light_deflection_angle: (a: number, b: number) => number;
+  readonly networkbatchoperations_computeAllPairwiseDistances: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly networkbatchoperations_geometricKMeansClustering: (a: number, b: number, c: number, d: number, e: number) => [number, number, number, number];
+  readonly performanceoperations_batchNormalize: (a: number, b: number, c: number) => [number, number];
+  readonly performanceoperations_fastGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly performanceoperations_vectorCrossProduct: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly performanceoperations_vectorDotProduct: (a: number, b: number, c: number, d: number) => number;
+  readonly validate_relativistic_module: () => number;
+  readonly velocity_to_gamma: (a: number) => [number, number, number];
+  readonly wasmfourvelocity_as_spacetime_vector: (a: number) => number;
+  readonly wasmfourvelocity_from_velocity: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmfourvelocity_gamma: (a: number) => number;
+  readonly wasmfourvelocity_is_normalized: (a: number) => number;
+  readonly wasmfourvelocity_rapidity: (a: number) => number;
+  readonly wasmfourvelocity_spatial_velocity_magnitude: (a: number) => number;
+  readonly wasmfourvelocity_to_string: (a: number) => [number, number];
+  readonly wasmgeodesicintegrator_propagate_particle: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly wasmgeodesicintegrator_with_schwarzschild: (a: number) => number;
+  readonly wasmgeometricnetwork_addEdge: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly wasmgeometricnetwork_addLabeledNode: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly wasmgeometricnetwork_addNode: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmgeometricnetwork_addUndirectedEdge: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly wasmgeometricnetwork_computeGeometricCentrality: (a: number) => [number, number, number, number];
+  readonly wasmgeometricnetwork_findCommunities: (a: number, b: number) => [number, number, number, number];
+  readonly wasmgeometricnetwork_geometricDistance: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmgeometricnetwork_getDegree: (a: number, b: number) => number;
+  readonly wasmgeometricnetwork_getNeighbors: (a: number, b: number) => [number, number];
+  readonly wasmgeometricnetwork_getNodePosition: (a: number, b: number) => [number, number];
+  readonly wasmgeometricnetwork_new: () => number;
+  readonly wasmgeometricnetwork_numEdges: (a: number) => number;
+  readonly wasmgeometricnetwork_numNodes: (a: number) => number;
+  readonly wasmgeometricnetwork_shortestPath: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly wasmgeometricnetwork_shortestPathWithDistance: (a: number, b: number, c: number) => [number, number, number];
+  readonly wasmmultivector_add: (a: number, b: number) => number;
   readonly wasmmultivector_basisVector: (a: number) => [number, number, number];
-  readonly wasmmultivector_getCoefficients: (a: number) => [number, number];
-  readonly wasmmultivector_getCoefficient: (a: number, b: number) => number;
-  readonly wasmmultivector_setCoefficient: (a: number, b: number, c: number) => void;
+  readonly wasmmultivector_exp: (a: number) => number;
+  readonly wasmmultivector_fromCoefficients: (a: number, b: number) => [number, number, number];
   readonly wasmmultivector_geometricProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_innerProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_outerProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_scalarProduct: (a: number, b: number) => number;
-  readonly wasmmultivector_reverse: (a: number) => number;
+  readonly wasmmultivector_getCoefficient: (a: number, b: number) => number;
+  readonly wasmmultivector_getCoefficients: (a: number) => [number, number];
   readonly wasmmultivector_gradeProjection: (a: number, b: number) => number;
-  readonly wasmmultivector_exp: (a: number) => number;
+  readonly wasmmultivector_innerProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_inverse: (a: number) => [number, number, number];
   readonly wasmmultivector_magnitude: (a: number) => number;
+  readonly wasmmultivector_new: () => number;
   readonly wasmmultivector_normalize: (a: number) => [number, number, number];
-  readonly wasmmultivector_inverse: (a: number) => [number, number, number];
-  readonly wasmmultivector_add: (a: number, b: number) => number;
-  readonly wasmmultivector_sub: (a: number, b: number) => number;
+  readonly wasmmultivector_outerProduct: (a: number, b: number) => number;
+  readonly wasmmultivector_reverse: (a: number) => number;
+  readonly wasmmultivector_scalar: (a: number) => number;
+  readonly wasmmultivector_scalarProduct: (a: number, b: number) => number;
   readonly wasmmultivector_scale: (a: number, b: number) => number;
-  readonly __wbg_batchoperations_free: (a: number, b: number) => void;
-  readonly batchoperations_batchGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly batchoperations_batchAdd: (a: number, b: number, c: number, d: number) => [number, number, number, number];
-  readonly wasmrotor_fromBivector: (a: number, b: number) => number;
+  readonly wasmmultivector_setCoefficient: (a: number, b: number, c: number) => void;
+  readonly wasmmultivector_sub: (a: number, b: number) => number;
+  readonly wasmrelativisticconstants_earth_mass: () => number;
+  readonly wasmrelativisticconstants_gravitational_constant: () => number;
+  readonly wasmrelativisticconstants_solar_mass: () => number;
+  readonly wasmrelativisticconstants_speed_of_light: () => number;
+  readonly wasmrelativisticparticle_charge: (a: number) => number;
+  readonly wasmrelativisticparticle_four_velocity: (a: number) => number;
+  readonly wasmrelativisticparticle_kinetic_energy: (a: number) => number;
+  readonly wasmrelativisticparticle_mass: (a: number) => number;
+  readonly wasmrelativisticparticle_momentum_magnitude: (a: number) => number;
+  readonly wasmrelativisticparticle_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
+  readonly wasmrelativisticparticle_position_3d: (a: number) => any;
+  readonly wasmrelativisticparticle_position_4d: (a: number) => number;
+  readonly wasmrelativisticparticle_to_string: (a: number) => [number, number];
+  readonly wasmrelativisticparticle_total_energy: (a: number) => number;
+  readonly wasmrelativisticparticle_with_energy: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
   readonly wasmrotor_apply: (a: number, b: number) => number;
   readonly wasmrotor_compose: (a: number, b: number) => number;
-  readonly performanceoperations_fastGeometricProduct: (a: number, b: number, c: number, d: number) => [number, number];
-  readonly performanceoperations_vectorCrossProduct: (a: number, b: number, c: number, d: number) => [number, number];
-  readonly performanceoperations_vectorDotProduct: (a: number, b: number, c: number, d: number) => number;
-  readonly performanceoperations_batchNormalize: (a: number, b: number, c: number) => [number, number];
-  readonly init: () => void;
+  readonly wasmrotor_fromBivector: (a: number, b: number) => number;
+  readonly wasmschwarzschildmetric_earth: () => number;
+  readonly wasmschwarzschildmetric_effective_potential: (a: number, b: number, c: number) => number;
+  readonly wasmschwarzschildmetric_from_mass: (a: number) => number;
+  readonly wasmschwarzschildmetric_has_singularity: (a: number, b: number) => number;
+  readonly wasmschwarzschildmetric_mass: (a: number) => number;
+  readonly wasmschwarzschildmetric_schwarzschild_radius: (a: number) => number;
+  readonly wasmschwarzschildmetric_sun: () => number;
+  readonly wasmspacetimevector_is_null: (a: number) => number;
+  readonly wasmspacetimevector_is_spacelike: (a: number) => number;
+  readonly wasmspacetimevector_is_timelike: (a: number) => number;
+  readonly wasmspacetimevector_minkowski_dot: (a: number, b: number) => number;
+  readonly wasmspacetimevector_new: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmspacetimevector_norm_squared: (a: number) => number;
+  readonly wasmspacetimevector_spacelike: (a: number, b: number, c: number) => number;
+  readonly wasmspacetimevector_timelike: (a: number) => number;
+  readonly wasmspacetimevector_to_string: (a: number) => [number, number];
+  readonly wasmspacetimevector_x: (a: number) => number;
+  readonly wasmspacetimevector_y: (a: number) => number;
+  readonly wasmspacetimevector_z: (a: number) => number;
   readonly wasmmultivector_norm: (a: number) => number;
+  readonly wasmspacetimevector_t: (a: number) => number;
+  readonly wasmtrajectorypoint_position: (a: number) => number;
+  readonly __wbg_networkbatchoperations_free: (a: number, b: number) => void;
   readonly __wbg_performanceoperations_free: (a: number, b: number) => void;
+  readonly __wbg_wasmrelativisticconstants_free: (a: number, b: number) => void;
+  readonly __wbg_wasmspacetimevector_free: (a: number, b: number) => void;
   readonly wasmrotor_inverse: (a: number) => number;
   readonly __wbg_wasmrotor_free: (a: number, b: number) => void;
-  readonly __wbindgen_export_0: WebAssembly.Table;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_start: () => void;