@aigentic/attention-unified-wasm 0.1.29

package/ruvector_attention_unified_wasm.d.ts

@@ -0,0 +1,790 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class DagAttentionFactory {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get available DAG attention types
+   */
+  static availableTypes(): any;
+  /**
+   * Get description for a DAG attention type
+   */
+  static getDescription(attention_type: string): string;
+}
+
+export class GraphAttentionFactory {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get recommended use cases for a graph attention type
+   */
+  static getUseCases(attention_type: string): any;
+  /**
+   * Get available graph attention types
+   */
+  static availableTypes(): any;
+  /**
+   * Get description for a graph attention type
+   */
+  static getDescription(attention_type: string): string;
+}
+
+/**
+ * Graph attention mechanism types
+ */
+export enum GraphAttentionType {
+  /**
+   * Graph Attention Networks (Velickovic et al., 2018)
+   */
+  GAT = 0,
+  /**
+   * Graph Convolutional Networks (Kipf & Welling, 2017)
+   */
+  GCN = 1,
+  /**
+   * GraphSAGE (Hamilton et al., 2017)
+   */
+  GraphSAGE = 2,
+}
+
+export class HybridMambaAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new hybrid Mamba-Attention layer
+   */
+  constructor(config: MambaConfig, local_window: number);
+  /**
+   * Forward pass
+   */
+  forward(input: Float32Array, seq_len: number): Float32Array;
+  /**
+   * Get local window size
+   */
+  readonly localWindow: number;
+}
+
+export class MambaConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Set state space dimension
+   */
+  withStateDim(state_dim: number): MambaConfig;
+  /**
+   * Set expansion factor
+   */
+  withExpandFactor(factor: number): MambaConfig;
+  /**
+   * Set convolution kernel size
+   */
+  withConvKernelSize(size: number): MambaConfig;
+  /**
+   * Create a new Mamba configuration
+   */
+  constructor(dim: number);
+  /**
+   * Model dimension (d_model)
+   */
+  dim: number;
+  /**
+   * State space dimension (n)
+   */
+  state_dim: number;
+  /**
+   * Expansion factor for inner dimension
+   */
+  expand_factor: number;
+  /**
+   * Convolution kernel size
+   */
+  conv_kernel_size: number;
+  /**
+   * Delta (discretization step) range minimum
+   */
+  dt_min: number;
+  /**
+   * Delta range maximum
+   */
+  dt_max: number;
+  /**
+   * Whether to use learnable D skip connection
+   */
+  use_d_skip: boolean;
+}
+
+export class MambaSSMAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create with default configuration
+   */
+  static withDefaults(dim: number): MambaSSMAttention;
+  /**
+   * Compute attention-like scores (for visualization/analysis)
+   *
+   * Returns pseudo-attention scores showing which positions influence output
+   */
+  getAttentionScores(input: Float32Array, seq_len: number): Float32Array;
+  /**
+   * Create a new Mamba SSM attention layer
+   */
+  constructor(config: MambaConfig);
+  /**
+   * Forward pass through Mamba SSM
+   *
+   * # Arguments
+   * * `input` - Input sequence (seq_len, dim) flattened to 1D
+   * * `seq_len` - Sequence length
+   *
+   * # Returns
+   * Output sequence (seq_len, dim) flattened to 1D
+   */
+  forward(input: Float32Array, seq_len: number): Float32Array;
+  /**
+   * Get the configuration
+   */
+  readonly config: MambaConfig;
+  /**
+   * Get the inner dimension
+   */
+  readonly innerDim: number;
+}
+
+export class UnifiedAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Check if this mechanism supports graph/DAG structures
+   */
+  supportsGraphs(): boolean;
+  /**
+   * Check if this mechanism supports sequence processing
+   */
+  supportsSequences(): boolean;
+  /**
+   * Check if this mechanism supports hyperbolic geometry
+   */
+  supportsHyperbolic(): boolean;
+  /**
+   * Create a new unified attention selector
+   */
+  constructor(mechanism: string);
+  /**
+   * Get the category of the selected mechanism
+   */
+  readonly category: string;
+  /**
+   * Get the currently selected mechanism type
+   */
+  readonly mechanism: string;
+}
+
+export class WasmCausalConeAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new causal cone attention instance
+   *
+   * # Arguments
+   * * `future_discount` - Discount for future nodes
+   * * `ancestor_weight` - Weight for ancestor influence
+   */
+  constructor(future_discount: number, ancestor_weight: number);
+  /**
+   * Compute attention scores for the DAG
+   */
+  forward(dag: WasmQueryDag): Float32Array;
+}
+
+export class WasmCriticalPathAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new critical path attention instance
+   *
+   * # Arguments
+   * * `path_weight` - Weight for critical path membership
+   * * `branch_penalty` - Penalty for branching nodes
+   */
+  constructor(path_weight: number, branch_penalty: number);
+  /**
+   * Compute attention scores for the DAG
+   */
+  forward(dag: WasmQueryDag): Float32Array;
+}
+
+export class WasmFlashAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new flash attention instance
+   *
+   * # Arguments
+   * * `dim` - Embedding dimension
+   * * `block_size` - Block size for tiled computation
+   */
+  constructor(dim: number, block_size: number);
+  /**
+   * Compute flash attention
+   */
+  compute(query: Float32Array, keys: any, values: any): Float32Array;
+}
+
+export class WasmGNNLayer {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new GNN layer with attention
+   *
+   * # Arguments
+   * * `input_dim` - Dimension of input node embeddings
+   * * `hidden_dim` - Dimension of hidden representations
+   * * `heads` - Number of attention heads
+   * * `dropout` - Dropout rate (0.0 to 1.0)
+   */
+  constructor(input_dim: number, hidden_dim: number, heads: number, dropout: number);
+  /**
+   * Forward pass through the GNN layer
+   *
+   * # Arguments
+   * * `node_embedding` - Current node's embedding (Float32Array)
+   * * `neighbor_embeddings` - Embeddings of neighbor nodes (array of Float32Arrays)
+   * * `edge_weights` - Weights of edges to neighbors (Float32Array)
+   *
+   * # Returns
+   * Updated node embedding (Float32Array)
+   */
+  forward(node_embedding: Float32Array, neighbor_embeddings: any, edge_weights: Float32Array): Float32Array;
+  /**
+   * Get the output dimension
+   */
+  readonly outputDim: number;
+}
+
+export class WasmHierarchicalLorentzAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new hierarchical Lorentz attention instance
+   *
+   * # Arguments
+   * * `curvature` - Hyperbolic curvature parameter
+   * * `temperature` - Temperature for softmax
+   */
+  constructor(curvature: number, temperature: number);
+  /**
+   * Compute attention scores for the DAG
+   */
+  forward(dag: WasmQueryDag): Float32Array;
+}
+
+export class WasmHyperbolicAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new hyperbolic attention instance
+   *
+   * # Arguments
+   * * `dim` - Embedding dimension
+   * * `curvature` - Hyperbolic curvature parameter (negative for hyperbolic space)
+   */
+  constructor(dim: number, curvature: number);
+  /**
+   * Compute hyperbolic attention
+   */
+  compute(query: Float32Array, keys: any, values: any): Float32Array;
+  /**
+   * Get the curvature parameter
+   */
+  readonly curvature: number;
+}
+
+export class WasmLinearAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new linear attention instance
+   *
+   * # Arguments
+   * * `dim` - Embedding dimension
+   * * `num_features` - Number of random features for kernel approximation
+   */
+  constructor(dim: number, num_features: number);
+  /**
+   * Compute linear attention
+   */
+  compute(query: Float32Array, keys: any, values: any): Float32Array;
+}
+
+export class WasmLocalGlobalAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new local-global attention instance
+   *
+   * # Arguments
+   * * `dim` - Embedding dimension
+   * * `local_window` - Size of local attention window
+   * * `global_tokens` - Number of global attention tokens
+   */
+  constructor(dim: number, local_window: number, global_tokens: number);
+  /**
+   * Compute local-global attention
+   */
+  compute(query: Float32Array, keys: any, values: any): Float32Array;
+}
+
+export class WasmMinCutGatedAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new MinCut-gated attention instance
+   *
+   * # Arguments
+   * * `gate_threshold` - Threshold for gating (0.0-1.0)
+   */
+  constructor(gate_threshold: number);
+  /**
+   * Compute attention scores for the DAG
+   */
+  forward(dag: WasmQueryDag): Float32Array;
+}
+
+export class WasmMoEAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new MoE attention instance
+   *
+   * # Arguments
+   * * `dim` - Embedding dimension
+   * * `num_experts` - Number of expert attention mechanisms
+   * * `top_k` - Number of experts to activate per query
+   */
+  constructor(dim: number, num_experts: number, top_k: number);
+  /**
+   * Compute MoE attention
+   */
+  compute(query: Float32Array, keys: any, values: any): Float32Array;
+}
+
+export class WasmMultiHeadAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new multi-head attention instance
+   *
+   * # Arguments
+   * * `dim` - Embedding dimension (must be divisible by num_heads)
+   * * `num_heads` - Number of parallel attention heads
+   */
+  constructor(dim: number, num_heads: number);
+  /**
+   * Compute multi-head attention
+   *
+   * # Arguments
+   * * `query` - Query vector
+   * * `keys` - Array of key vectors
+   * * `values` - Array of value vectors
+   */
+  compute(query: Float32Array, keys: any, values: any): Float32Array;
+  /**
+   * Get the embedding dimension
+   */
+  readonly dim: number;
+  /**
+   * Get the dimension per head
+   */
+  readonly headDim: number;
+  /**
+   * Get the number of attention heads
+   */
+  readonly numHeads: number;
+}
+
+export class WasmParallelBranchAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new parallel branch attention instance
+   *
+   * # Arguments
+   * * `max_branches` - Maximum number of branches to consider
+   * * `sync_penalty` - Penalty for synchronization between branches
+   */
+  constructor(max_branches: number, sync_penalty: number);
+  /**
+   * Compute attention scores for the DAG
+   */
+  forward(dag: WasmQueryDag): Float32Array;
+}
+
+export class WasmQueryDag {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new empty DAG
+   */
+  constructor();
+  /**
+   * Serialize to JSON
+   */
+  toJson(): string;
+  /**
+   * Add an edge between nodes
+   *
+   * # Arguments
+   * * `from` - Source node ID
+   * * `to` - Target node ID
+   *
+   * # Returns
+   * True if edge was added successfully
+   */
+  addEdge(from: number, to: number): boolean;
+  /**
+   * Add a node with operator type and cost
+   *
+   * # Arguments
+   * * `op_type` - Operator type: "scan", "filter", "join", "aggregate", "project", "sort"
+   * * `cost` - Estimated execution cost
+   *
+   * # Returns
+   * Node ID
+   */
+  addNode(op_type: string, cost: number): number;
+  /**
+   * Get the number of edges
+   */
+  readonly edgeCount: number;
+  /**
+   * Get the number of nodes
+   */
+  readonly nodeCount: number;
+}
+
+export class WasmSearchConfig {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new search configuration
+   */
+  constructor(k: number, temperature: number);
+  /**
+   * Number of top results to return
+   */
+  k: number;
+  /**
+   * Temperature for softmax
+   */
+  temperature: number;
+}
+
+export class WasmTemporalBTSPAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new temporal BTSP attention instance
+   *
+   * # Arguments
+   * * `eligibility_decay` - Decay rate for eligibility traces (0.0-1.0)
+   * * `baseline_attention` - Baseline attention for nodes without history
+   */
+  constructor(eligibility_decay: number, baseline_attention: number);
+  /**
+   * Compute attention scores for the DAG
+   */
+  forward(dag: WasmQueryDag): Float32Array;
+}
+
+export class WasmTensorCompress {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Decompress a compressed tensor
+   */
+  decompress(compressed: any): Float32Array;
+  /**
+   * Compress with explicit compression level
+   *
+   * # Arguments
+   * * `embedding` - The input embedding vector
+   * * `level` - Compression level: "none", "half", "pq8", "pq4", "binary"
+   */
+  compressWithLevel(embedding: Float32Array, level: string): any;
+  /**
+   * Get compression ratio estimate for a given access frequency
+   */
+  getCompressionRatio(access_freq: number): number;
+  /**
+   * Create a new tensor compressor
+   */
+  constructor();
+  /**
+   * Compress an embedding based on access frequency
+   *
+   * # Arguments
+   * * `embedding` - The input embedding vector
+   * * `access_freq` - Access frequency in range [0.0, 1.0]
+   *   - f > 0.8: Full precision (hot data)
+   *   - f > 0.4: Half precision (warm data)
+   *   - f > 0.1: 8-bit PQ (cool data)
+   *   - f > 0.01: 4-bit PQ (cold data)
+   *   - f <= 0.01: Binary (archive)
+   */
+  compress(embedding: Float32Array, access_freq: number): any;
+}
+
+export class WasmTopologicalAttention {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a new topological attention instance
+   *
+   * # Arguments
+   * * `decay_factor` - Decay factor for position-based attention (0.0-1.0)
+   */
+  constructor(decay_factor: number);
+  /**
+   * Compute attention scores for the DAG
+   *
+   * # Returns
+   * Attention scores for each node
+   */
+  forward(dag: WasmQueryDag): Float32Array;
+}
+
+/**
+ * Get information about all available attention mechanisms
+ */
+export function availableMechanisms(): any;
+
+/**
+ * Compute cosine similarity between two vectors
+ */
+export function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+
+/**
+ * Get summary statistics about the unified attention library
+ */
+export function getStats(): any;
+
+/**
+ * Differentiable search using soft attention mechanism
+ *
+ * # Arguments
+ * * `query` - The query vector
+ * * `candidate_embeddings` - List of candidate embedding vectors
+ * * `config` - Search configuration
+ *
+ * # Returns
+ * Object with indices and weights for top-k candidates
+ */
+export function graphDifferentiableSearch(query: Float32Array, candidate_embeddings: any, config: WasmSearchConfig): any;
+
+/**
+ * Hierarchical forward pass through multiple GNN layers
+ *
+ * # Arguments
+ * * `query` - The query vector
+ * * `layer_embeddings` - Embeddings organized by layer
+ * * `gnn_layers` - Array of GNN layers
+ *
+ * # Returns
+ * Final embedding after hierarchical processing
+ */
+export function graphHierarchicalForward(query: Float32Array, layer_embeddings: any, gnn_layers: WasmGNNLayer[]): Float32Array;
+
+/**
+ * Initialize the WASM module with panic hook for better error messages
+ */
+export function init(): void;
+
+/**
+ * Compute scaled dot-product attention
+ *
+ * Standard transformer attention: softmax(QK^T / sqrt(d)) * V
+ *
+ * # Arguments
+ * * `query` - Query vector (Float32Array)
+ * * `keys` - Array of key vectors (JsValue - array of Float32Arrays)
+ * * `values` - Array of value vectors (JsValue - array of Float32Arrays)
+ * * `scale` - Optional scaling factor (defaults to 1/sqrt(dim))
+ *
+ * # Returns
+ * Attention-weighted output vector
+ */
+export function scaledDotAttention(query: Float32Array, keys: any, values: any, scale?: number | null): Float32Array;
+
+/**
+ * Softmax normalization
+ */
+export function softmax(values: Float32Array): Float32Array;
+
+/**
+ * Temperature-scaled softmax
+ */
+export function temperatureSoftmax(values: Float32Array, temperature: number): Float32Array;
+
+/**
+ * Get the version of the unified attention WASM crate
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_dagattentionfactory_free: (a: number, b: number) => void;
+  readonly __wbg_get_mambaconfig_conv_kernel_size: (a: number) => number;
+  readonly __wbg_get_mambaconfig_dim: (a: number) => number;
+  readonly __wbg_get_mambaconfig_dt_max: (a: number) => number;
+  readonly __wbg_get_mambaconfig_dt_min: (a: number) => number;
+  readonly __wbg_get_mambaconfig_expand_factor: (a: number) => number;
+  readonly __wbg_get_mambaconfig_state_dim: (a: number) => number;
+  readonly __wbg_get_mambaconfig_use_d_skip: (a: number) => number;
+  readonly __wbg_get_wasmsearchconfig_temperature: (a: number) => number;
+  readonly __wbg_hybridmambaattention_free: (a: number, b: number) => void;
+  readonly __wbg_mambaconfig_free: (a: number, b: number) => void;
+  readonly __wbg_mambassmattention_free: (a: number, b: number) => void;
+  readonly __wbg_set_mambaconfig_conv_kernel_size: (a: number, b: number) => void;
+  readonly __wbg_set_mambaconfig_dim: (a: number, b: number) => void;
+  readonly __wbg_set_mambaconfig_dt_max: (a: number, b: number) => void;
+  readonly __wbg_set_mambaconfig_dt_min: (a: number, b: number) => void;
+  readonly __wbg_set_mambaconfig_expand_factor: (a: number, b: number) => void;
+  readonly __wbg_set_mambaconfig_state_dim: (a: number, b: number) => void;
+  readonly __wbg_set_mambaconfig_use_d_skip: (a: number, b: number) => void;
+  readonly __wbg_set_wasmsearchconfig_temperature: (a: number, b: number) => void;
+  readonly __wbg_unifiedattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmcausalconeattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmflashattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmgnnlayer_free: (a: number, b: number) => void;
+  readonly __wbg_wasmhyperbolicattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmlinearattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmincutgatedattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmoeattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmmultiheadattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmquerydag_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtensorcompress_free: (a: number, b: number) => void;
+  readonly availableMechanisms: () => number;
+  readonly cosineSimilarity: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly dagattentionfactory_availableTypes: () => number;
+  readonly dagattentionfactory_getDescription: (a: number, b: number, c: number) => void;
+  readonly getStats: () => number;
+  readonly graphDifferentiableSearch: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly graphHierarchicalForward: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly graphattentionfactory_availableTypes: () => number;
+  readonly graphattentionfactory_getDescription: (a: number, b: number, c: number) => void;
+  readonly graphattentionfactory_getUseCases: (a: number, b: number) => number;
+  readonly hybridmambaattention_forward: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly hybridmambaattention_localWindow: (a: number) => number;
+  readonly hybridmambaattention_new: (a: number, b: number) => number;
+  readonly mambaconfig_new: (a: number) => number;
+  readonly mambaconfig_withConvKernelSize: (a: number, b: number) => number;
+  readonly mambaconfig_withExpandFactor: (a: number, b: number) => number;
+  readonly mambaconfig_withStateDim: (a: number, b: number) => number;
+  readonly mambassmattention_config: (a: number) => number;
+  readonly mambassmattention_forward: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly mambassmattention_getAttentionScores: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly mambassmattention_innerDim: (a: number) => number;
+  readonly mambassmattention_new: (a: number) => number;
+  readonly mambassmattention_withDefaults: (a: number) => number;
+  readonly scaledDotAttention: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly softmax: (a: number, b: number, c: number) => void;
+  readonly temperatureSoftmax: (a: number, b: number, c: number, d: number) => void;
+  readonly unifiedattention_category: (a: number, b: number) => void;
+  readonly unifiedattention_mechanism: (a: number, b: number) => void;
+  readonly unifiedattention_new: (a: number, b: number, c: number) => void;
+  readonly unifiedattention_supportsGraphs: (a: number) => number;
+  readonly unifiedattention_supportsHyperbolic: (a: number) => number;
+  readonly unifiedattention_supportsSequences: (a: number) => number;
+  readonly version: (a: number) => void;
+  readonly wasmcausalconeattention_forward: (a: number, b: number, c: number) => void;
+  readonly wasmcriticalpathattention_forward: (a: number, b: number, c: number) => void;
+  readonly wasmflashattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly wasmflashattention_new: (a: number, b: number) => number;
+  readonly wasmgnnlayer_forward: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly wasmgnnlayer_new: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly wasmgnnlayer_outputDim: (a: number) => number;
+  readonly wasmhierarchicallorentzattention_forward: (a: number, b: number, c: number) => void;
+  readonly wasmhyperbolicattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly wasmhyperbolicattention_curvature: (a: number) => number;
+  readonly wasmhyperbolicattention_new: (a: number, b: number) => number;
+  readonly wasmlinearattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly wasmlinearattention_new: (a: number, b: number) => number;
+  readonly wasmlocalglobalattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly wasmlocalglobalattention_new: (a: number, b: number, c: number) => number;
+  readonly wasmmincutgatedattention_forward: (a: number, b: number, c: number) => void;
+  readonly wasmmoeattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly wasmmoeattention_new: (a: number, b: number, c: number) => number;
+  readonly wasmmultiheadattention_compute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly wasmmultiheadattention_dim: (a: number) => number;
+  readonly wasmmultiheadattention_headDim: (a: number) => number;
+  readonly wasmmultiheadattention_new: (a: number, b: number, c: number) => void;
+  readonly wasmmultiheadattention_numHeads: (a: number) => number;
+  readonly wasmparallelbranchattention_forward: (a: number, b: number, c: number) => void;
+  readonly wasmquerydag_addEdge: (a: number, b: number, c: number) => number;
+  readonly wasmquerydag_addNode: (a: number, b: number, c: number, d: number) => number;
+  readonly wasmquerydag_edgeCount: (a: number) => number;
+  readonly wasmquerydag_new: () => number;
+  readonly wasmquerydag_nodeCount: (a: number) => number;
+  readonly wasmquerydag_toJson: (a: number, b: number) => void;
+  readonly wasmtemporalbtspattention_forward: (a: number, b: number, c: number) => void;
+  readonly wasmtensorcompress_compress: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly wasmtensorcompress_compressWithLevel: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly wasmtensorcompress_decompress: (a: number, b: number, c: number) => void;
+  readonly wasmtensorcompress_getCompressionRatio: (a: number, b: number) => number;
+  readonly wasmtensorcompress_new: () => number;
+  readonly wasmtopologicalattention_forward: (a: number, b: number, c: number) => void;
+  readonly init: () => void;
+  readonly wasmmincutgatedattention_new: (a: number) => number;
+  readonly wasmtopologicalattention_new: (a: number) => number;
+  readonly __wbg_set_wasmsearchconfig_k: (a: number, b: number) => void;
+  readonly wasmcausalconeattention_new: (a: number, b: number) => number;
+  readonly wasmcriticalpathattention_new: (a: number, b: number) => number;
+  readonly wasmhierarchicallorentzattention_new: (a: number, b: number) => number;
+  readonly wasmparallelbranchattention_new: (a: number, b: number) => number;
+  readonly wasmsearchconfig_new: (a: number, b: number) => number;
+  readonly wasmtemporalbtspattention_new: (a: number, b: number) => number;
+  readonly __wbg_get_wasmsearchconfig_k: (a: number) => number;
+  readonly __wbg_graphattentionfactory_free: (a: number, b: number) => void;
+  readonly __wbg_wasmcriticalpathattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmhierarchicallorentzattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmlocalglobalattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmparallelbranchattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmsearchconfig_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtemporalbtspattention_free: (a: number, b: number) => void;
+  readonly __wbg_wasmtopologicalattention_free: (a: number, b: number) => void;
+  readonly __wbindgen_export: (a: number, b: number) => number;
+  readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export3: (a: number) => void;
+  readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;