numpy-ts 1.2.0 → 1.3.0

package/dist/types/common/dtype.d.ts

@@ -21,6 +21,12 @@ export type TypedArray = Float64Array | Float32Array | Float16Array | BigInt64Ar
  * When false, float16 dtype uses Float32Array as a fallback backing store.
  */
 export declare const hasFloat16: boolean;
+/**
+ * Returns the effective dtype for WASM kernel dispatch.
+ * When Float16Array is unavailable, float16 storage is backed by Float32Array,
+ * so WASM kernels should treat it as float32.
+ */
+export declare function effectiveDType(dtype: DType): DType;
 /**
  * Default dtype (matches NumPy)
  */
@@ -72,6 +78,11 @@ export declare function isComplexDType(dtype: DType): boolean;
  * ```
  */
 export declare function throwIfComplex(dtype: DType, functionName: string, reason?: string): void;
+/**
+ * Throw a TypeError if the dtype is bool and the operation doesn't support it.
+ * Matches NumPy 2.x behavior where boolean arithmetic (negative, subtract, etc.) is rejected.
+ */
+export declare function throwIfBool(dtype: DType, functionName: string, reason?: string): void;
 /**
  * Throw an error if the dtype is complex and the function doesn't yet support it.
  * Use this for functions that SHOULD support complex but haven't been implemented yet.
@@ -113,6 +124,41 @@ export declare function inferDType(value: unknown): DType;
  * Follows NumPy's type promotion rules
  */
 export declare function promoteDTypes(dtype1: DType, dtype2: DType): DType;
+/**
+ * Result dtype for unary math functions (sin, cos, sqrt, exp, log, etc.).
+ * Maps input dtype to the "minimum float" that can represent it.
+ *
+ * bool/int8/uint8  → float16 (if available, else float32)
+ * int16/uint16     → float32
+ * int32+/uint32+   → float64
+ * float/complex    → same dtype (preserved)
+ */
+export declare function mathResultDtype(inputDtype: DType): DType;
+/**
+ * Result dtype for bool inputs in arithmetic ops that promote bool → int8.
+ * Used by: power, mod, floor_divide, remainder, square.
+ */
+export declare function boolArithmeticDtype(inputDtype: DType): DType;
+/**
+ * Result dtype for reduction accumulation (sum, prod, cumsum, cumprod).
+ * NumPy accumulates small integers in wider types to prevent overflow.
+ *
+ * bool/int8/int16/int32  → int64
+ * uint8/uint16/uint32    → uint64
+ * int64/uint64           → same
+ * float/complex          → same
+ */
+export declare function reductionAccumDtype(inputDtype: DType): DType;
+/**
+ * Result dtype for FFT functions.
+ * float32 → complex64, everything else → complex128.
+ */
+export declare function fftResultDtype(inputDtype: DType): DType;
+/**
+ * Result dtype for real-output FFT functions (hfft).
+ * float16/float32/complex64 → float32, everything else → float64.
+ */
+export declare function fftRealResultDtype(inputDtype: DType): DType;
 /**
  * Validate dtype string
  */

package/dist/types/common/internal/indexing.d.ts

@@ -24,4 +24,13 @@ export declare function precomputeAxisOffsets(shape: readonly number[], strides:
     baseOffsets: Int32Array;
     axisStride: number;
 };
+/**
+ * Replaces '...' with an appropriate number of ':'.
+ * If there's not '...', it's implicit at the end.
+ *
+ *
+ * So the result of this function will have length ndim + newaxisCount
+ * where newaxisCount is the number of 'newaxis' in the input.
+ */
+export declare function expandEllipsis<T>(indices: (T | string)[], ndim: number): (T | string)[];
 //# sourceMappingURL=indexing.d.ts.map

package/dist/types/common/ndarray-core.d.ts

@@ -107,10 +107,30 @@ export declare class NDArrayCore {
      * Return the raw bytes of the array data
      */
     tobytes(): ArrayBuffer;
+    /**
+     * Eagerly free the WASM memory backing this array.
+     *
+     * In normal usage, WASM memory is freed automatically when the array is
+     * garbage collected. Call dispose() to free immediately in tight loops,
+     * benchmarks, or resource-sensitive contexts.
+     *
+     * Also available as `[Symbol.dispose]` on supported runtimes, enabling
+     * the `using` keyword for automatic scope-based cleanup:
+     * ```ts
+     * {
+     *   using result = np.add(a, b);
+     *   // use result...
+     * } // automatically freed here
+     * ```
+     * Safari does not yet support `Symbol.dispose` — use `.dispose()` directly
+     * for cross-browser compatibility.
+     */
+    dispose(): void;
     /**
      * Copy an element of an array to a standard scalar and return it
      */
     item(...args: number[]): number | bigint | Complex;
+    [Symbol.dispose]?: () => void;
 }
 export type { DType, TypedArray };
 //# sourceMappingURL=ndarray-core.d.ts.map

package/dist/types/common/ops/advanced.d.ts

@@ -88,11 +88,11 @@ export declare function triu_indices_from(storage: ArrayStorage, k?: number): Ar
 /**
  * Return indices to access elements using mask function
  */
-export declare function mask_indices(n: number, mask_func: (n: number, k: number) => ArrayStorage, k?: number): ArrayStorage[];
+export declare function mask_indices(n: number, mask_func: (m: ArrayStorage, k: number) => ArrayStorage, k?: number): ArrayStorage[];
 /**
  * Return array representing indices of a grid
  */
-export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): ArrayStorage;
+export declare function indices(dimensions: number[], dtype?: string): ArrayStorage;
 /**
  * Construct open mesh from multiple sequences
  */
@@ -177,4 +177,19 @@ export declare function geterr(): FloatErrorState;
  * @returns Previous error handling settings
  */
 export declare function seterr(all?: ErrorMode, divide?: ErrorMode, over?: ErrorMode, under?: ErrorMode, invalid?: ErrorMode): FloatErrorState;
+type StorageIndex = number | string | number[] | ArrayStorage;
+/**
+ * Vectorized multi-dimensional indexing.
+ *
+ * Integer-array subspace dimensions come first in the output, followed by
+ * slice dimensions in their original order.
+ *
+ * Supported index types:
+ *   number        — scalar, removes the dimension
+ *   string '1:4'  — range slice
+ *   string '...'  — ellipsis, expands to fill remaining dimensions
+ *   number[]      — cast to 1-d integer index array
+ *   ArrayStorage  — integer array indexing
+ */
+export declare function vindex(a: ArrayStorage, ...indices: StorageIndex[]): ArrayStorage;
 //# sourceMappingURL=advanced.d.ts.map

package/dist/types/common/ops/complex.d.ts

@@ -2,7 +2,7 @@
  * Complex number operations
  *
  * Pure functions for complex array operations:
- * real, imag, conj, angle
+ * real, imag, conj, angle, clipComplex, and shared complex-indexing helpers
  *
  * @module ops/complex
  */
@@ -62,4 +62,22 @@ export declare function angle(a: ArrayStorage, deg?: boolean): ArrayStorage;
  * @returns Array with magnitudes
  */
 export declare function complexAbs(a: ArrayStorage): ArrayStorage;
+/**
+ * Get real and imaginary parts from an interleaved complex array at logical index i.
+ */
+export declare function getComplexAt(data: Float64Array | Float32Array, i: number): [number, number];
+/**
+ * Set real and imaginary parts in an interleaved complex array at logical index i.
+ */
+export declare function setComplexAt(data: Float64Array | Float32Array, i: number, re: number, im: number): void;
+/**
+ * NumPy lexicographic comparison for complex: compare real parts first,
+ * then imaginary parts as tiebreaker.
+ * Returns true if a > b.
+ */
+export declare function complexGreater(aRe: number, aIm: number, bRe: number, bIm: number): boolean;
+/**
+ * Clip complex array: compare by real part first, imaginary as tiebreaker (lexicographic).
+ */
+export declare function clipComplex(a: ArrayStorage, a_min: number | ArrayStorage | null, a_max: number | ArrayStorage | null): ArrayStorage;
 //# sourceMappingURL=complex.d.ts.map

package/dist/types/common/ops/linalg.d.ts

@@ -247,7 +247,7 @@ export declare function svd(a: ArrayStorage, full_matrices?: boolean, compute_uv
  * @param a - Square matrix
  * @returns Determinant
  */
-export declare function det(a: ArrayStorage): number | ArrayStorage;
+export declare function det(a: ArrayStorage): number | Complex | ArrayStorage;
 /**
  * Compute the matrix inverse - optimized to do LU decomposition once.
  *

package/dist/types/common/ops/reduction.d.ts

@@ -81,7 +81,7 @@ export declare function ptp(storage: ArrayStorage, axis?: number, keepdims?: boo
 /**
  * Compute the median along the specified axis
  */
-export declare function median(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function median(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute the q-th percentile of data along specified axis
  */
@@ -141,7 +141,7 @@ export declare function nancumprod(storage: ArrayStorage, axis?: number): ArrayS
 /**
  * Compute median ignoring NaN values
  */
-export declare function nanmedian(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+export declare function nanmedian(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number | Complex;
 /**
  * Compute the q-th quantile of data along specified axis, ignoring NaNs
  */

package/dist/types/common/ops/sets.d.ts

@@ -12,7 +12,8 @@ export declare function unique(a: ArrayStorage, returnIndex?: boolean, returnInv
     counts?: ArrayStorage;
 };
 /**
- * Test whether each element of a 1-D array is also present in a second array
+ * Test whether each element of a 1-D array is also present in a second array.
+ * @deprecated Use {@link isin} instead. `in1d` follows NumPy's deprecation and will be removed in a future release.
  */
 export declare function in1d(ar1: ArrayStorage, ar2: ArrayStorage): ArrayStorage;
 /**

package/dist/types/common/ops/shape.d.ts

@@ -9,13 +9,13 @@ import { ArrayStorage } from '../storage';
  * Slice an array along one or more dimensions
  * Returns a view (no data copy) with adjusted shape, strides, and offset
  */
-export declare function slice(storage: ArrayStorage, ...sliceStrs: string[]): ArrayStorage;
+export declare function slice(storage: ArrayStorage, ...slices: (string | number)[]): ArrayStorage;
 /**
  * Slice an array along one or more dimensions, keeping all dimensions (rank-preserving)
  * Like slice(), but integer-index specs produce a size-1 dimension instead of dropping it.
  * Returns a view (no data copy) with adjusted shape, strides, and offset
  */
-export declare function sliceKeepDim(storage: ArrayStorage, ...sliceStrs: string[]): ArrayStorage;
+export declare function sliceKeepDim(storage: ArrayStorage, ...slices: string[]): ArrayStorage;
 /**
  * Reshape array to a new shape
  * Returns a view if array is C-contiguous, otherwise copies data

package/dist/types/common/ops/statistics.d.ts

@@ -5,6 +5,7 @@
  * @module ops/statistics
  */
 import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
 /**
  * Count number of occurrences of each value in array of non-negative ints.
  *
@@ -126,5 +127,5 @@ export declare function histogram_bin_edges(a: ArrayStorage, bins?: number | 'au
  * @param axis - The axis along which to integrate (default: -1, meaning last axis)
  * @returns Definite integral approximated using the composite trapezoidal rule
  */
-export declare function trapezoid(y: ArrayStorage, x?: ArrayStorage, dx?: number, axis?: number): ArrayStorage | number;
+export declare function trapezoid(y: ArrayStorage, x?: ArrayStorage, dx?: number, axis?: number): ArrayStorage | number | Complex;
 //# sourceMappingURL=statistics.d.ts.map

package/dist/types/common/storage.d.ts

@@ -7,6 +7,7 @@
  */
 import { type DType, type TypedArray } from './dtype';
 import { Complex } from './complex';
+import { type WasmRegion } from './wasm/runtime';
 /**
  * Maximum number of dimensions an array can have (matches NumPy's limit).
  */
@@ -16,13 +17,15 @@ export declare const MAX_NDIM = 64;
  * Manages the underlying TypedArray and metadata
  */
 export declare class ArrayStorage {
+    [Symbol.dispose]?: () => void;
     private _data;
     private _shape;
     private _strides;
     private _offset;
     private _dtype;
     private _isCContiguous;
-    constructor(data: TypedArray, shape: readonly number[], strides: readonly number[], offset: number, dtype: DType);
+    private _wasmRegion;
+    constructor(data: TypedArray, shape: readonly number[], strides: readonly number[], offset: number, dtype: DType, wasmRegion?: WasmRegion | null);
     /**
      * Shape of the array
      */
@@ -51,6 +54,35 @@ export declare class ArrayStorage {
      * Offset into the data buffer
      */
     get offset(): number;
+    /**
+     * Whether this storage is backed by WASM linear memory (zero-copy eligible).
+     */
+    get isWasmBacked(): boolean;
+    /**
+     * Eagerly free the WASM memory backing this storage.
+     *
+     * In normal usage, WASM memory is freed automatically via FinalizationRegistry
+     * when the storage is garbage collected. Call dispose() to free immediately
+     * when you know this storage will not be used again — useful in tight loops,
+     * benchmarks, or resource-sensitive contexts.
+     *
+     * Also available as `[Symbol.dispose]` on runtimes that support it (Node 18+,
+     * Chrome 134+, Firefox 132+), enabling the `using` keyword for automatic
+     * scope-based cleanup. Safari does not yet support `Symbol.dispose`, so use
+     * this method directly for cross-browser compatibility.
+     */
+    dispose(): void;
+    /**
+     * Byte offset of the start of the allocation in WASM memory.
+     * Returns 0 if not WASM-backed (safe for use with resolveInputPtr).
+     * @internal
+     */
+    get wasmPtr(): number;
+    /**
+     * The underlying WasmRegion for view sharing.
+     * @internal
+     */
+    get wasmRegion(): WasmRegion | null;
     /**
      * Check if array is C-contiguous (row-major, no gaps)
      */
@@ -90,13 +122,33 @@ export declare class ArrayStorage {
      */
     copy(): ArrayStorage;
     /**
-     * Create storage from TypedArray data
+     * Create storage from TypedArray data.
+     * If the data is not already in WASM memory, copies it there (one-time cost).
      */
     static fromData(data: TypedArray, shape: number[], dtype: DType, strides?: number[], offset?: number): ArrayStorage;
+    /**
+     * Create a view sharing the same backing WASM region.
+     * Increments the WasmRegion refcount so the memory is not freed
+     * until all views are garbage collected.
+     * @internal
+     */
+    static fromDataShared(data: TypedArray, shape: number[], dtype: DType, strides: number[], offset: number, wasmRegion: WasmRegion | null): ArrayStorage;
+    /**
+     * Create storage with a WASM-backed output region.
+     * Used by kernel wrappers to construct output directly in WASM memory.
+     * @internal
+     */
+    static fromWasmRegion(shape: number[], dtype: DType, region: WasmRegion, elementCount: number, Ctor: new (buffer: ArrayBuffer, byteOffset: number, length: number) => TypedArray): ArrayStorage;
     /**
      * Create storage with zeros
      */
     static zeros(shape: number[], dtype?: DType): ArrayStorage;
+    /**
+     * Allocate uninitialized storage for output buffers.
+     * Like zeros() but skips zero-fill — use only when the caller will fully overwrite the data.
+     * @internal
+     */
+    static empty(shape: number[], dtype?: DType): ArrayStorage;
     /**
      * Create storage with ones
      */

package/dist/types/common/wasm/all_finite.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WASM-accelerated "all finite" check.
+ * Returns true if every element is finite, false if any NaN or Inf found.
+ * Early-exits on first non-finite value.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmAllFinite(a: ArrayStorage): boolean | null;
+//# sourceMappingURL=all_finite.d.ts.map

package/dist/types/common/wasm/arccos.d.ts

@@ -3,8 +3,10 @@
  *
  * Unary: out[i] = acos(a[i])
  * Returns null if WASM can't handle this case.
- * Float types use native kernels; integer types are converted to float64
- * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

package/dist/types/common/wasm/arcsin.d.ts

@@ -3,8 +3,10 @@
  *
  * Unary: out[i] = asin(a[i])
  * Returns null if WASM can't handle this case.
- * Float types use native kernels; integer types are converted to float64
- * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

package/dist/types/common/wasm/arctan.d.ts

@@ -3,8 +3,10 @@
  *
  * Unary: out[i] = arctan(a[i])
  * Returns null if WASM can't handle this case.
- * Float types use native kernels; integer types are converted to float64
- * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

package/dist/types/common/wasm/arctan2.d.ts

@@ -0,0 +1,17 @@
+/**
+ * WASM-accelerated element-wise arctan2.
+ *
+ * Binary: out[i] = atan2(a[i], b[i])  (same-shape contiguous arrays)
+ * Returns null if WASM can't handle this case.
+ * Integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise arctan2 of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmArctan2(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=arctan2.d.ts.map

package/dist/types/common/wasm/argpartition.d.ts

@@ -1,18 +1,23 @@
 /**
  * WASM-accelerated argpartition (returns indices for quickselect partition).
  *
+ * Output is float64 indices for JS ergonomics (no BigInt).
+ * WASM partitions u32 internally and converts to f64 before returning.
  * Returns null if WASM can't handle this case.
  */
 import { ArrayStorage } from '../storage';
-import type { DType, TypedArray } from '../dtype';
+import { type DType, TypedArray } from '../dtype';
 /**
  * WASM-accelerated argpartition of contiguous slices.
  * Uses batch kernel when slices are packed contiguously.
+ *
+ * Note: operates on pre-existing JS buffers (inputData/resultData), uses scratch.
+ * resultData is Float64Array (f64 indices).
  */
-export declare function wasmArgpartitionSlices(inputData: TypedArray, resultData: Int32Array, inputSliceOffsets: Int32Array | number[], outputSliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, kth: number, dtype: DType): boolean;
+export declare function wasmArgpartitionSlices(inputData: TypedArray, resultData: Float64Array, inputSliceOffsets: Int32Array | number[], outputSliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, kth: number, dtype: DType): boolean;
 /**
  * WASM-accelerated argpartition of a contiguous 1D buffer.
- * Returns ArrayStorage of int32 indices or null if WASM can't handle it.
+ * Returns ArrayStorage of float64 indices or null if WASM can't handle it.
  */
 export declare function wasmArgpartition(a: ArrayStorage, kth: number): ArrayStorage | null;
 //# sourceMappingURL=argpartition.d.ts.map

package/dist/types/common/wasm/argsort.d.ts

@@ -1,18 +1,23 @@
 /**
  * WASM-accelerated argsort (returns indices that would sort an array).
  *
+ * Output is float64 indices for JS ergonomics (no BigInt).
+ * WASM sorts u32 internally and converts to f64 before returning.
  * Returns null if WASM can't handle this case.
  */
 import { ArrayStorage } from '../storage';
-import type { DType, TypedArray } from '../dtype';
+import { type DType, TypedArray } from '../dtype';
 /**
  * WASM-accelerated argsort of contiguous slices.
  * Uses batch kernel when slices are packed contiguously.
+ *
+ * Note: operates on pre-existing JS buffers (inputData/resultData), uses scratch.
+ * resultData is Float64Array (f64 indices).
  */
-export declare function wasmArgsortSlices(inputData: TypedArray, resultData: Int32Array, inputSliceOffsets: Int32Array | number[], outputSliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, dtype: DType): boolean;
+export declare function wasmArgsortSlices(inputData: TypedArray, resultData: Float64Array, inputSliceOffsets: Int32Array | number[], outputSliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, dtype: DType): boolean;
 /**
  * WASM-accelerated argsort of a contiguous 1D buffer.
- * Returns ArrayStorage of int32 indices or null if WASM can't handle it.
+ * Returns ArrayStorage of float64 indices or null if WASM can't handle it.
  */
 export declare function wasmArgsort(a: ArrayStorage): ArrayStorage | null;
 //# sourceMappingURL=argsort.d.ts.map

package/dist/types/common/wasm/bins/abs.wasm.d.ts

@@ -1,5 +1,6 @@
 export declare function abs_f64(a: number, out: number, N: number): void;
 export declare function abs_f32(a: number, out: number, N: number): void;
+export declare function abs_f16(a: number, out: number, N: number): void;
 export declare function abs_i64(a: number, out: number, N: number): void;
 export declare function abs_i32(a: number, out: number, N: number): void;
 export declare function abs_i16(a: number, out: number, N: number): void;

package/dist/types/common/wasm/bins/all_finite.wasm.d.ts

@@ -0,0 +1,4 @@
+export declare function all_finite_f64(a: number, N: number): number;
+export declare function all_finite_f32(a: number, N: number): number;
+export declare function all_finite_u16(a: number, N: number): number;
+//# sourceMappingURL=all_finite.wasm.d.ts.map

package/dist/types/common/wasm/bins/alloc.wasm.d.ts

@@ -0,0 +1,6 @@
+export declare function heap_init(base: number, size: number): void;
+export declare function heap_malloc(req_size: number): number;
+export declare function heap_free(ptr: number): void;
+export declare function heap_realloc(ptr: number, new_size: number): number;
+export declare function heap_free_bytes(): number;
+//# sourceMappingURL=alloc.wasm.d.ts.map

package/dist/types/common/wasm/bins/arccos.wasm.d.ts

@@ -1,5 +1,11 @@
 export declare function arccos_f64(a: number, out: number, N: number): void;
 export declare function arccos_f32(a: number, out: number, N: number): void;
-export declare function arccos_i64(a: number, out: number, N: number): void;
-export declare function arccos_u64(a: number, out: number, N: number): void;
+export declare function arccos_i64_f64(a: number, out: number, N: number): void;
+export declare function arccos_u64_f64(a: number, out: number, N: number): void;
+export declare function arccos_i32_f64(a: number, out: number, N: number): void;
+export declare function arccos_u32_f64(a: number, out: number, N: number): void;
+export declare function arccos_i16_f32(a: number, out: number, N: number): void;
+export declare function arccos_u16_f32(a: number, out: number, N: number): void;
+export declare function arccos_i8_f32(a: number, out: number, N: number): void;
+export declare function arccos_u8_f32(a: number, out: number, N: number): void;
 //# sourceMappingURL=arccos.wasm.d.ts.map

package/dist/types/common/wasm/bins/arcsin.wasm.d.ts

@@ -1,5 +1,11 @@
 export declare function arcsin_f64(a: number, out: number, N: number): void;
 export declare function arcsin_f32(a: number, out: number, N: number): void;
-export declare function arcsin_i64(a: number, out: number, N: number): void;
-export declare function arcsin_u64(a: number, out: number, N: number): void;
+export declare function arcsin_i64_f64(a: number, out: number, N: number): void;
+export declare function arcsin_u64_f64(a: number, out: number, N: number): void;
+export declare function arcsin_i32_f64(a: number, out: number, N: number): void;
+export declare function arcsin_u32_f64(a: number, out: number, N: number): void;
+export declare function arcsin_i16_f32(a: number, out: number, N: number): void;
+export declare function arcsin_u16_f32(a: number, out: number, N: number): void;
+export declare function arcsin_i8_f32(a: number, out: number, N: number): void;
+export declare function arcsin_u8_f32(a: number, out: number, N: number): void;
 //# sourceMappingURL=arcsin.wasm.d.ts.map

package/dist/types/common/wasm/bins/arctan.wasm.d.ts

@@ -1,5 +1,11 @@
 export declare function arctan_f64(a: number, out: number, N: number): void;
 export declare function arctan_f32(a: number, out: number, N: number): void;
-export declare function arctan_i64(a: number, out: number, N: number): void;
-export declare function arctan_u64(a: number, out: number, N: number): void;
+export declare function arctan_i64_f64(a: number, out: number, N: number): void;
+export declare function arctan_u64_f64(a: number, out: number, N: number): void;
+export declare function arctan_i32_f64(a: number, out: number, N: number): void;
+export declare function arctan_u32_f64(a: number, out: number, N: number): void;
+export declare function arctan_i16_f32(a: number, out: number, N: number): void;
+export declare function arctan_u16_f32(a: number, out: number, N: number): void;
+export declare function arctan_i8_f32(a: number, out: number, N: number): void;
+export declare function arctan_u8_f32(a: number, out: number, N: number): void;
 //# sourceMappingURL=arctan.wasm.d.ts.map

package/dist/types/common/wasm/bins/arctan2.wasm.d.ts

@@ -0,0 +1,11 @@
+export declare function arctan2_f64(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_f32(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_i64_f64(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_u64_f64(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_i32_f64(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_u32_f64(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_i16_f32(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_u16_f32(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_i8_f32(a: number, b: number, out: number, N: number): void;
+export declare function arctan2_u8_f32(a: number, b: number, out: number, N: number): void;
+//# sourceMappingURL=arctan2.wasm.d.ts.map

package/dist/types/common/wasm/bins/convolve.wasm.d.ts

@@ -1,3 +1,9 @@
 export declare function convolve_f64(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
 export declare function convolve_f32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function convolve_i32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function convolve_u32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function convolve_i16(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function convolve_u16(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function convolve_i8(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function convolve_u8(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
 //# sourceMappingURL=convolve.wasm.d.ts.map

package/dist/types/common/wasm/bins/copysign.wasm.d.ts

@@ -1,5 +1,7 @@
 export declare function copysign_f64(x1: number, x2: number, out: number, N: number): void;
 export declare function copysign_f32(x1: number, x2: number, out: number, N: number): void;
+export declare function copysign_f16(a: number, b: number, out: number, N: number): void;
+export declare function copysign_scalar_f16(a: number, out: number, N: number, scalar_sign: number): void;
 export declare function copysign_i64(x1: number, x2: number, out: number, N: number): void;
 export declare function copysign_u64(x1: number, x2: number, out: number, N: number): void;
 export declare function copysign_i32(x1: number, x2: number, out: number, N: number): void;

package/dist/types/common/wasm/bins/correlate.wasm.d.ts

@@ -1,3 +1,9 @@
 export declare function correlate_f64(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
 export declare function correlate_f32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function correlate_i32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function correlate_u32(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function correlate_i16(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function correlate_u16(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function correlate_i8(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
+export declare function correlate_u8(a: number, na: number, b: number, nb: number, out: number, outLen: number): void;
 //# sourceMappingURL=correlate.wasm.d.ts.map

package/dist/types/common/wasm/bins/cos.wasm.d.ts

@@ -1,3 +1,11 @@
 export declare function cos_f64(a: number, out: number, N: number): void;
 export declare function cos_f32(a: number, out: number, N: number): void;
+export declare function cos_i64_f64(a: number, out: number, N: number): void;
+export declare function cos_u64_f64(a: number, out: number, N: number): void;
+export declare function cos_i32_f64(a: number, out: number, N: number): void;
+export declare function cos_u32_f64(a: number, out: number, N: number): void;
+export declare function cos_i16_f32(a: number, out: number, N: number): void;
+export declare function cos_u16_f32(a: number, out: number, N: number): void;
+export declare function cos_i8_f32(a: number, out: number, N: number): void;
+export declare function cos_u8_f32(a: number, out: number, N: number): void;
 //# sourceMappingURL=cos.wasm.d.ts.map

package/dist/types/common/wasm/bins/cosh.wasm.d.ts

@@ -1,5 +1,11 @@
 export declare function cosh_f64(a: number, out: number, N: number): void;
 export declare function cosh_f32(a: number, out: number, N: number): void;
-export declare function cosh_i64(a: number, out: number, N: number): void;
-export declare function cosh_u64(a: number, out: number, N: number): void;
+export declare function cosh_i64_f64(a: number, out: number, N: number): void;
+export declare function cosh_u64_f64(a: number, out: number, N: number): void;
+export declare function cosh_i32_f64(a: number, out: number, N: number): void;
+export declare function cosh_u32_f64(a: number, out: number, N: number): void;
+export declare function cosh_i16_f32(a: number, out: number, N: number): void;
+export declare function cosh_u16_f32(a: number, out: number, N: number): void;
+export declare function cosh_i8_f32(a: number, out: number, N: number): void;
+export declare function cosh_u8_f32(a: number, out: number, N: number): void;
 //# sourceMappingURL=cosh.wasm.d.ts.map

package/dist/types/common/wasm/bins/divmod.wasm.d.ts

@@ -0,0 +1,11 @@
+export declare function divmod_scalar_f64(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_f32(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_i64(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_u64(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_i32(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_u32(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_i16(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_u16(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_i8(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+export declare function divmod_scalar_u8(a: number, out_q: number, out_r: number, N: number, scalar: number): void;
+//# sourceMappingURL=divmod.wasm.d.ts.map

package/dist/types/common/wasm/bins/dot_float-relaxed.wasm.d.ts

@@ -0,0 +1,5 @@
+export declare function dot_f64(a: number, b: number, out: number, K: number): void;
+export declare function dot_f32(a: number, b: number, out: number, K: number): void;
+export declare function dot_c128(a: number, b: number, out: number, K: number): void;
+export declare function dot_c64(a: number, b: number, out: number, K: number): void;
+//# sourceMappingURL=dot_float-relaxed.wasm.d.ts.map