numpy-ts 0.3.0 → 0.5.0

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

@@ -135,6 +135,101 @@ export declare class NDArray {
      * @returns New array with signs
      */
     sign(): NDArray;
+    /**
+     * Sine of each element (in radians)
+     * Promotes integer types to float64
+     * @returns New array with sine values
+     */
+    sin(): NDArray;
+    /**
+     * Cosine of each element (in radians)
+     * Promotes integer types to float64
+     * @returns New array with cosine values
+     */
+    cos(): NDArray;
+    /**
+     * Tangent of each element (in radians)
+     * Promotes integer types to float64
+     * @returns New array with tangent values
+     */
+    tan(): NDArray;
+    /**
+     * Inverse sine of each element
+     * Promotes integer types to float64
+     * @returns New array with arcsin values (radians)
+     */
+    arcsin(): NDArray;
+    /**
+     * Inverse cosine of each element
+     * Promotes integer types to float64
+     * @returns New array with arccos values (radians)
+     */
+    arccos(): NDArray;
+    /**
+     * Inverse tangent of each element
+     * Promotes integer types to float64
+     * @returns New array with arctan values (radians)
+     */
+    arctan(): NDArray;
+    /**
+     * Element-wise arc tangent of this/other choosing the quadrant correctly
+     * @param other - x-coordinates (array or scalar)
+     * @returns Angle in radians between -π and π
+     */
+    arctan2(other: NDArray | number): NDArray;
+    /**
+     * Given the "legs" of a right triangle, return its hypotenuse
+     * Equivalent to sqrt(this**2 + other**2), element-wise
+     * @param other - Second leg (array or scalar)
+     * @returns Hypotenuse values
+     */
+    hypot(other: NDArray | number): NDArray;
+    /**
+     * Convert angles from radians to degrees
+     * @returns New array with angles in degrees
+     */
+    degrees(): NDArray;
+    /**
+     * Convert angles from degrees to radians
+     * @returns New array with angles in radians
+     */
+    radians(): NDArray;
+    /**
+     * Hyperbolic sine of each element
+     * Promotes integer types to float64
+     * @returns New array with sinh values
+     */
+    sinh(): NDArray;
+    /**
+     * Hyperbolic cosine of each element
+     * Promotes integer types to float64
+     * @returns New array with cosh values
+     */
+    cosh(): NDArray;
+    /**
+     * Hyperbolic tangent of each element
+     * Promotes integer types to float64
+     * @returns New array with tanh values
+     */
+    tanh(): NDArray;
+    /**
+     * Inverse hyperbolic sine of each element
+     * Promotes integer types to float64
+     * @returns New array with arcsinh values
+     */
+    arcsinh(): NDArray;
+    /**
+     * Inverse hyperbolic cosine of each element
+     * Promotes integer types to float64
+     * @returns New array with arccosh values
+     */
+    arccosh(): NDArray;
+    /**
+     * Inverse hyperbolic tangent of each element
+     * Promotes integer types to float64
+     * @returns New array with arctanh values
+     */
+    arctanh(): NDArray;
     /**
      * Element-wise greater than comparison
      * @param other - Value or array to compare with
@@ -303,12 +398,76 @@ export declare class NDArray {
      * @returns Array with additional dimension (always a view)
      */
     expand_dims(axis: number): NDArray;
+    /**
+     * Swap two axes of an array
+     * @param axis1 - First axis
+     * @param axis2 - Second axis
+     * @returns Array with swapped axes (always a view)
+     */
+    swapaxes(axis1: number, axis2: number): NDArray;
+    /**
+     * Move axes to new positions
+     * @param source - Original positions of axes to move
+     * @param destination - New positions for axes
+     * @returns Array with moved axes (always a view)
+     */
+    moveaxis(source: number | number[], destination: number | number[]): NDArray;
+    /**
+     * Repeat elements of an array
+     * @param repeats - Number of repetitions for each element
+     * @param axis - Axis along which to repeat (if undefined, flattens first)
+     * @returns New array with repeated elements
+     */
+    repeat(repeats: number | number[], axis?: number): NDArray;
+    /**
+     * Take elements from array along an axis
+     * @param indices - Indices of elements to take
+     * @param axis - Axis along which to take (if undefined, flattens first)
+     * @returns New array with selected elements
+     */
+    take(indices: number[], axis?: number): NDArray;
+    /**
+     * Put values at specified indices (modifies array in-place)
+     * @param indices - Indices at which to place values
+     * @param values - Values to put
+     */
+    put(indices: number[], values: NDArray | number | bigint): void;
     /**
      * Matrix multiplication
      * @param other - Array to multiply with
      * @returns Result of matrix multiplication
      */
     matmul(other: NDArray): NDArray;
+    /**
+     * Dot product (matching NumPy behavior)
+     * @param other - Array to dot with
+     * @returns Result of dot product (scalar or array depending on dimensions)
+     */
+    dot(other: NDArray): NDArray | number | bigint;
+    /**
+     * Sum of diagonal elements (trace)
+     * @returns Sum of diagonal elements
+     */
+    trace(): number | bigint;
+    /**
+     * Inner product (contracts over last axes of both arrays)
+     * @param other - Array to compute inner product with
+     * @returns Inner product result
+     */
+    inner(other: NDArray): NDArray | number | bigint;
+    /**
+     * Outer product (flattens inputs then computes a[i]*b[j])
+     * @param other - Array to compute outer product with
+     * @returns 2D outer product matrix
+     */
+    outer(other: NDArray): NDArray;
+    /**
+     * Tensor dot product along specified axes
+     * @param other - Array to contract with
+     * @param axes - Axes to contract (integer or [a_axes, b_axes])
+     * @returns Tensor dot product result
+     */
+    tensordot(other: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint;
     /**
      * Slice the array using NumPy-style string syntax
      *
@@ -545,4 +704,322 @@ export declare function positive(x: NDArray): NDArray;
  * @returns Array of reciprocals
  */
 export declare function reciprocal(x: NDArray): NDArray;
+/**
+ * Dot product of two arrays
+ *
+ * Fully NumPy-compatible. Behavior depends on input dimensions:
+ * - 0D · 0D: Multiply scalars → scalar
+ * - 0D · ND or ND · 0D: Element-wise multiply → ND
+ * - 1D · 1D: Inner product → scalar
+ * - 2D · 2D: Matrix multiplication → 2D
+ * - 2D · 1D: Matrix-vector product → 1D
+ * - 1D · 2D: Vector-matrix product → 1D
+ * - ND · 1D (N>2): Sum over last axis → (N-1)D
+ * - 1D · ND (N>2): Sum over first axis → (N-1)D
+ * - ND · MD (N,M≥2): Tensor contraction → (N+M-2)D
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @returns Result of dot product
+ */
+export declare function dot(a: NDArray, b: NDArray): NDArray | number | bigint;
+/**
+ * Sum of diagonal elements
+ *
+ * @param a - Input 2D array
+ * @returns Sum of diagonal elements
+ */
+export declare function trace(a: NDArray): number | bigint;
+/**
+ * Permute array dimensions
+ *
+ * @param a - Input array
+ * @param axes - Optional permutation of axes (defaults to reverse order)
+ * @returns Transposed view
+ */
+export declare function transpose(a: NDArray, axes?: number[]): NDArray;
+/**
+ * Inner product of two arrays
+ *
+ * Contracts over last axes of both arrays.
+ * Result shape: (*a.shape[:-1], *b.shape[:-1])
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @returns Inner product result
+ */
+export declare function inner(a: NDArray, b: NDArray): NDArray | number | bigint;
+/**
+ * Outer product of two arrays
+ *
+ * Flattens inputs then computes result[i,j] = a[i] * b[j]
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @returns 2D outer product matrix
+ */
+export declare function outer(a: NDArray, b: NDArray): NDArray;
+/**
+ * Tensor dot product along specified axes
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @param axes - Axes to contract (integer or [a_axes, b_axes])
+ * @returns Tensor dot product
+ */
+export declare function tensordot(a: NDArray, b: NDArray, axes?: number | [number[], number[]]): NDArray | number | bigint;
+/**
+ * Element-wise sine
+ * @param x - Input array (angles in radians)
+ * @returns Array of sine values
+ */
+export declare function sin(x: NDArray): NDArray;
+/**
+ * Element-wise cosine
+ * @param x - Input array (angles in radians)
+ * @returns Array of cosine values
+ */
+export declare function cos(x: NDArray): NDArray;
+/**
+ * Element-wise tangent
+ * @param x - Input array (angles in radians)
+ * @returns Array of tangent values
+ */
+export declare function tan(x: NDArray): NDArray;
+/**
+ * Element-wise inverse sine
+ * @param x - Input array (values in range [-1, 1])
+ * @returns Array of angles in radians
+ */
+export declare function arcsin(x: NDArray): NDArray;
+/**
+ * Element-wise inverse cosine
+ * @param x - Input array (values in range [-1, 1])
+ * @returns Array of angles in radians
+ */
+export declare function arccos(x: NDArray): NDArray;
+/**
+ * Element-wise inverse tangent
+ * @param x - Input array
+ * @returns Array of angles in radians
+ */
+export declare function arctan(x: NDArray): NDArray;
+/**
+ * Element-wise arc tangent of x1/x2 choosing the quadrant correctly
+ * @param x1 - y-coordinates
+ * @param x2 - x-coordinates (array or scalar)
+ * @returns Angles in radians between -π and π
+ */
+export declare function arctan2(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Given the "legs" of a right triangle, return its hypotenuse
+ * Equivalent to sqrt(x1**2 + x2**2), element-wise
+ * @param x1 - First leg
+ * @param x2 - Second leg (array or scalar)
+ * @returns Hypotenuse values
+ */
+export declare function hypot(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Convert angles from radians to degrees
+ * @param x - Input array (angles in radians)
+ * @returns Angles in degrees
+ */
+export declare function degrees(x: NDArray): NDArray;
+/**
+ * Convert angles from degrees to radians
+ * @param x - Input array (angles in degrees)
+ * @returns Angles in radians
+ */
+export declare function radians(x: NDArray): NDArray;
+/**
+ * Element-wise hyperbolic sine
+ * @param x - Input array
+ * @returns Array of sinh values
+ */
+export declare function sinh(x: NDArray): NDArray;
+/**
+ * Element-wise hyperbolic cosine
+ * @param x - Input array
+ * @returns Array of cosh values
+ */
+export declare function cosh(x: NDArray): NDArray;
+/**
+ * Element-wise hyperbolic tangent
+ * @param x - Input array
+ * @returns Array of tanh values
+ */
+export declare function tanh(x: NDArray): NDArray;
+/**
+ * Element-wise inverse hyperbolic sine
+ * @param x - Input array
+ * @returns Array of arcsinh values
+ */
+export declare function arcsinh(x: NDArray): NDArray;
+/**
+ * Element-wise inverse hyperbolic cosine
+ * @param x - Input array (values >= 1)
+ * @returns Array of arccosh values
+ */
+export declare function arccosh(x: NDArray): NDArray;
+/**
+ * Element-wise inverse hyperbolic tangent
+ * @param x - Input array (values in range (-1, 1))
+ * @returns Array of arctanh values
+ */
+export declare function arctanh(x: NDArray): NDArray;
+/**
+ * Swap two axes of an array
+ *
+ * @param a - Input array
+ * @param axis1 - First axis
+ * @param axis2 - Second axis
+ * @returns View with axes swapped
+ */
+export declare function swapaxes(a: NDArray, axis1: number, axis2: number): NDArray;
+/**
+ * Move axes to new positions
+ *
+ * @param a - Input array
+ * @param source - Original positions of axes to move
+ * @param destination - New positions for axes
+ * @returns View with axes moved
+ */
+export declare function moveaxis(a: NDArray, source: number | number[], destination: number | number[]): NDArray;
+/**
+ * Concatenate arrays along an existing axis
+ *
+ * @param arrays - Arrays to concatenate
+ * @param axis - Axis along which to concatenate (default: 0)
+ * @returns Concatenated array
+ */
+export declare function concatenate(arrays: NDArray[], axis?: number): NDArray;
+/**
+ * Stack arrays along a new axis
+ *
+ * @param arrays - Arrays to stack (must have same shape)
+ * @param axis - Axis in the result array along which to stack (default: 0)
+ * @returns Stacked array
+ */
+export declare function stack(arrays: NDArray[], axis?: number): NDArray;
+/**
+ * Stack arrays vertically (row-wise)
+ *
+ * @param arrays - Arrays to stack
+ * @returns Vertically stacked array
+ */
+export declare function vstack(arrays: NDArray[]): NDArray;
+/**
+ * Stack arrays horizontally (column-wise)
+ *
+ * @param arrays - Arrays to stack
+ * @returns Horizontally stacked array
+ */
+export declare function hstack(arrays: NDArray[]): NDArray;
+/**
+ * Stack arrays depth-wise (along third axis)
+ *
+ * @param arrays - Arrays to stack
+ * @returns Depth-stacked array
+ */
+export declare function dstack(arrays: NDArray[]): NDArray;
+/**
+ * Split array into multiple sub-arrays
+ *
+ * @param a - Array to split
+ * @param indicesOrSections - Number of equal sections or indices where to split
+ * @param axis - Axis along which to split (default: 0)
+ * @returns List of sub-arrays
+ */
+export declare function split(a: NDArray, indicesOrSections: number | number[], axis?: number): NDArray[];
+/**
+ * Split array into multiple sub-arrays (allows unequal splits)
+ *
+ * @param a - Array to split
+ * @param indicesOrSections - Number of sections or indices where to split
+ * @param axis - Axis along which to split (default: 0)
+ * @returns List of sub-arrays
+ */
+export declare function array_split(a: NDArray, indicesOrSections: number | number[], axis?: number): NDArray[];
+/**
+ * Split array vertically (row-wise)
+ *
+ * @param a - Array to split
+ * @param indicesOrSections - Number of sections or indices where to split
+ * @returns List of sub-arrays
+ */
+export declare function vsplit(a: NDArray, indicesOrSections: number | number[]): NDArray[];
+/**
+ * Split array horizontally (column-wise)
+ *
+ * @param a - Array to split
+ * @param indicesOrSections - Number of sections or indices where to split
+ * @returns List of sub-arrays
+ */
+export declare function hsplit(a: NDArray, indicesOrSections: number | number[]): NDArray[];
+/**
+ * Tile array by repeating along each axis
+ *
+ * @param a - Input array
+ * @param reps - Number of repetitions along each axis
+ * @returns Tiled array
+ */
+export declare function tile(a: NDArray, reps: number | number[]): NDArray;
+/**
+ * Repeat elements of an array
+ *
+ * @param a - Input array
+ * @param repeats - Number of repetitions for each element
+ * @param axis - Axis along which to repeat (if undefined, flattens first)
+ * @returns Array with repeated elements
+ */
+export declare function repeat(a: NDArray, repeats: number | number[], axis?: number): NDArray;
+/**
+ * Broadcast an array to a given shape
+ *
+ * @param a - Input array
+ * @param shape - Target shape
+ * @returns View broadcast to target shape
+ */
+export declare function broadcast_to(a: NDArray, shape: number[]): NDArray;
+/**
+ * Broadcast arrays to a common shape
+ *
+ * @param arrays - Arrays to broadcast
+ * @returns Arrays broadcast to common shape
+ */
+export declare function broadcast_arrays(...arrays: NDArray[]): NDArray[];
+/**
+ * Take elements from an array along an axis
+ *
+ * @param a - Input array
+ * @param indices - Indices of elements to take
+ * @param axis - Axis along which to take (if undefined, flattens first)
+ * @returns Array with selected elements
+ */
+export declare function take(a: NDArray, indices: number[], axis?: number): NDArray;
+/**
+ * Put values at specified indices (modifies array in-place)
+ *
+ * @param a - Target array
+ * @param indices - Indices at which to place values
+ * @param values - Values to put
+ */
+export declare function put(a: NDArray, indices: number[], values: NDArray | number | bigint): void;
+/**
+ * Construct array from index array and choices
+ *
+ * @param a - Index array (integer indices into choices)
+ * @param choices - Arrays to choose from
+ * @returns Array constructed from choices
+ */
+export declare function choose(a: NDArray, choices: NDArray[]): NDArray;
+/**
+ * Check if two arrays are element-wise equal
+ *
+ * @param a - First array
+ * @param b - Second array
+ * @param equal_nan - Whether to consider NaN equal to NaN (default: false)
+ * @returns True if arrays are equal element-wise
+ */
+export declare function array_equal(a: NDArray, b: NDArray, equal_nan?: boolean): boolean;
 //# sourceMappingURL=ndarray.d.ts.map

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@
  *
  * @module numpy-ts
  */
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, } from './core/ndarray';
+export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, dot, trace, transpose, inner, outer, tensordot, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, broadcast_to, broadcast_arrays, take, put, choose, array_equal, } from './core/ndarray';
+export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/io/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * IO module for numpy-ts
+ *
+ * This module provides parsing and serialization for NPY and NPZ formats.
+ * These functions work with bytes (Uint8Array/ArrayBuffer) and are environment-agnostic.
+ *
+ * For file system operations (save/load), use the Node.js-specific entry point:
+ *   import { save, load } from 'numpy-ts/node';
+ *
+ * For browser usage, use fetch or FileReader to get the bytes, then use these functions.
+ */
+export { parseNpy, parseNpyHeader, parseNpyData } from './npy/parser';
+export { serializeNpy } from './npy/serializer';
+export { UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, } from './npy/format';
+export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, type NpzParseResult, } from './npz/parser';
+export { serializeNpz, serializeNpzSync, type NpzSerializeOptions } from './npz/serializer';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/io/npy/format.d.ts

@@ -0,0 +1,91 @@
+/**
+ * NPY file format constants and type definitions
+ *
+ * NPY is NumPy's native binary format for storing arrays.
+ * Spec: https://numpy.org/doc/stable/reference/generated/numpy.lib.format.html
+ */
+import type { DType } from '../../core/dtype';
+/**
+ * NPY magic number: \x93NUMPY (6 bytes)
+ */
+export declare const NPY_MAGIC: Uint8Array<ArrayBuffer>;
+/**
+ * Supported NPY format versions
+ * - v1.0: 2-byte header length (max 65535 bytes)
+ * - v2.0: 4-byte header length (max 4GB)
+ * - v3.0: allows UTF-8 in description (same as v2 otherwise)
+ *
+ * We read v1, v2, and v3; we write v2 only
+ */
+export interface NpyVersion {
+    major: number;
+    minor: number;
+}
+/**
+ * NPY header information
+ */
+export interface NpyHeader {
+    /** Data type descriptor (e.g., '<f8', '>i4') */
+    descr: string;
+    /** Whether array is Fortran-contiguous (column-major) */
+    fortran_order: boolean;
+    /** Array shape */
+    shape: number[];
+}
+/**
+ * Parsed NPY metadata including version
+ */
+export interface NpyMetadata {
+    version: NpyVersion;
+    header: NpyHeader;
+    /** Byte offset where data starts */
+    dataOffset: number;
+}
+/**
+ * Result of parsing an NPY header descriptor to our DType
+ */
+export interface DTypeParseResult {
+    dtype: DType;
+    /** Whether the data needs byte swapping (big-endian on little-endian or vice versa) */
+    needsByteSwap: boolean;
+    /** Element size in bytes */
+    itemsize: number;
+}
+/**
+ * All dtypes we support
+ */
+export declare const SUPPORTED_DTYPES: DType[];
+/**
+ * Detect system endianness
+ */
+export declare function isSystemLittleEndian(): boolean;
+/**
+ * DType to NPY descriptor mapping (for serialization)
+ * We always write little-endian
+ */
+export declare const DTYPE_TO_DESCR: Record<DType, string>;
+/**
+ * Unsupported dtype types (for error messages)
+ */
+export declare const UNSUPPORTED_DTYPE_PATTERNS: Record<string, string>;
+/**
+ * Parse a NumPy dtype descriptor string to our DType
+ *
+ * @param descr - NumPy descriptor like '<f8', '>i4', '|b1'
+ * @returns Parsed result with dtype and byte order info
+ * @throws Error if dtype is not supported
+ */
+export declare function parseDescriptor(descr: string): DTypeParseResult;
+/**
+ * Custom error for unsupported dtypes
+ */
+export declare class UnsupportedDTypeError extends Error {
+    constructor(message: string);
+}
+/**
+ * Custom error for invalid NPY format
+ */
+export declare class InvalidNpyError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=format.d.ts.map

package/dist/types/io/npy/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * NPY format reading and writing
+ */
+export { parseNpy, parseNpyHeader, parseNpyData } from './parser';
+export { serializeNpy } from './serializer';
+export { NPY_MAGIC, DTYPE_TO_DESCR, SUPPORTED_DTYPES, parseDescriptor, isSystemLittleEndian, UnsupportedDTypeError, InvalidNpyError, type NpyVersion, type NpyHeader, type NpyMetadata, type DTypeParseResult, } from './format';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/io/npy/parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * NPY file parser
+ *
+ * Parses NumPy .npy files (both v1 and v2/v3 formats) into NDArray objects.
+ */
+import { NDArray } from '../../core/ndarray';
+import { type NpyMetadata } from './format';
+/**
+ * Parse an NPY file from a Uint8Array or ArrayBuffer
+ *
+ * @param buffer - The NPY file contents
+ * @returns An NDArray containing the parsed data
+ * @throws InvalidNpyError if the file format is invalid
+ * @throws UnsupportedDTypeError if the dtype is not supported
+ */
+export declare function parseNpy(buffer: ArrayBuffer | Uint8Array): NDArray;
+/**
+ * Parse just the NPY header without reading the data
+ *
+ * @param bytes - The NPY file bytes
+ * @returns Parsed metadata including version, header, and data offset
+ */
+export declare function parseNpyHeader(bytes: Uint8Array): NpyMetadata;
+/**
+ * Parse the data section of an NPY file given parsed metadata
+ */
+export declare function parseNpyData(bytes: Uint8Array, metadata: NpyMetadata): NDArray;
+//# sourceMappingURL=parser.d.ts.map

package/dist/types/io/npy/serializer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * NPY file serializer
+ *
+ * Serializes NDArray objects to NumPy .npy format (v3.0).
+ * Always writes in little-endian, C-contiguous order.
+ *
+ * v3.0 is identical to v2.0 but allows UTF-8 in dtype descriptions.
+ */
+import { NDArray } from '../../core/ndarray';
+/**
+ * Serialize an NDArray to NPY format (v3.0)
+ *
+ * @param arr - The NDArray to serialize
+ * @returns A Uint8Array containing the NPY file data
+ */
+export declare function serializeNpy(arr: NDArray): Uint8Array;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/types/io/npz/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * NPZ format reading and writing
+ */
+export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, type NpzParseResult, } from './parser';
+export { serializeNpz, serializeNpzSync, type NpzSerializeOptions, type NpzArraysInput, } from './serializer';
+//# sourceMappingURL=index.d.ts.map