numpy-ts 0.7.0 → 0.9.0

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

@@ -120,6 +120,66 @@ export declare class NDArray {
      * @returns New array with powered values
      */
     power(exponent: NDArray | number): NDArray;
+    /**
+     * Natural exponential (e^x) of each element
+     * Promotes integer types to float64
+     * @returns New array with exp values
+     */
+    exp(): NDArray;
+    /**
+     * Base-2 exponential (2^x) of each element
+     * Promotes integer types to float64
+     * @returns New array with exp2 values
+     */
+    exp2(): NDArray;
+    /**
+     * Exponential minus one (e^x - 1) of each element
+     * More accurate than exp(x) - 1 for small x
+     * Promotes integer types to float64
+     * @returns New array with expm1 values
+     */
+    expm1(): NDArray;
+    /**
+     * Natural logarithm (ln) of each element
+     * Promotes integer types to float64
+     * @returns New array with log values
+     */
+    log(): NDArray;
+    /**
+     * Base-2 logarithm of each element
+     * Promotes integer types to float64
+     * @returns New array with log2 values
+     */
+    log2(): NDArray;
+    /**
+     * Base-10 logarithm of each element
+     * Promotes integer types to float64
+     * @returns New array with log10 values
+     */
+    log10(): NDArray;
+    /**
+     * Natural logarithm of (1 + x) of each element
+     * More accurate than log(1 + x) for small x
+     * Promotes integer types to float64
+     * @returns New array with log1p values
+     */
+    log1p(): NDArray;
+    /**
+     * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+     * More numerically stable than computing the expression directly
+     * Promotes integer types to float64
+     * @param x2 - Second operand (array or scalar)
+     * @returns New array with logaddexp values
+     */
+    logaddexp(x2: NDArray | number): NDArray;
+    /**
+     * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+     * More numerically stable than computing the expression directly
+     * Promotes integer types to float64
+     * @param x2 - Second operand (array or scalar)
+     * @returns New array with logaddexp2 values
+     */
+    logaddexp2(x2: NDArray | number): NDArray;
     /**
      * Absolute value of each element
      * @returns New array with absolute values
@@ -135,6 +195,43 @@ export declare class NDArray {
      * @returns New array with signs
      */
     sign(): NDArray;
+    /**
+     * Round an array to the given number of decimals
+     * @param decimals - Number of decimal places to round to (default: 0)
+     * @returns New array with rounded values
+     */
+    around(decimals?: number): NDArray;
+    /**
+     * Round an array to the given number of decimals (alias for around)
+     * @param decimals - Number of decimal places to round to (default: 0)
+     * @returns New array with rounded values
+     */
+    round(decimals?: number): NDArray;
+    /**
+     * Return the ceiling of the input, element-wise
+     * @returns New array with ceiling values
+     */
+    ceil(): NDArray;
+    /**
+     * Round to nearest integer towards zero
+     * @returns New array with values truncated towards zero
+     */
+    fix(): NDArray;
+    /**
+     * Return the floor of the input, element-wise
+     * @returns New array with floor values
+     */
+    floor(): NDArray;
+    /**
+     * Round elements to the nearest integer
+     * @returns New array with rounded integer values
+     */
+    rint(): NDArray;
+    /**
+     * Return the truncated value of the input, element-wise
+     * @returns New array with truncated values
+     */
+    trunc(): NDArray;
     /**
      * Sine of each element (in radians)
      * Promotes integer types to float64
@@ -534,6 +631,51 @@ export declare class NDArray {
      * @returns Median of array elements ignoring NaNs
      */
     nanmedian(axis?: number, keepdims?: boolean): NDArray | number;
+    /**
+     * Return a sorted copy of the array
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Sorted array
+     */
+    sort(axis?: number): NDArray;
+    /**
+     * Returns the indices that would sort this array
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Array of indices that sort the array
+     */
+    argsort(axis?: number): NDArray;
+    /**
+     * Partially sort the array
+     * @param kth - Element index to partition by
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Partitioned array
+     */
+    partition(kth: number, axis?: number): NDArray;
+    /**
+     * Returns indices that would partition the array
+     * @param kth - Element index to partition by
+     * @param axis - Axis along which to sort. Default is -1 (last axis)
+     * @returns Array of indices
+     */
+    argpartition(kth: number, axis?: number): NDArray;
+    /**
+     * Return the indices of non-zero elements
+     * @returns Tuple of arrays, one for each dimension
+     */
+    nonzero(): NDArray[];
+    /**
+     * Find indices where elements should be inserted to maintain order
+     * @param v - Values to insert
+     * @param side - 'left' or 'right' side to insert
+     * @returns Indices where values should be inserted
+     */
+    searchsorted(v: NDArray, side?: 'left' | 'right'): NDArray;
+    /**
+     * Calculate the n-th discrete difference along the given axis
+     * @param n - Number of times values are differenced (default: 1)
+     * @param axis - Axis along which to compute difference (default: -1)
+     * @returns Array of differences
+     */
+    diff(n?: number, axis?: number): NDArray;
     /**
      * Reshape array to a new shape
      * Returns a new array with the specified shape
@@ -989,6 +1131,66 @@ export declare function sqrt(x: NDArray): NDArray;
  * @returns Array of x raised to exponent
  */
 export declare function power(x: NDArray, exponent: NDArray | number): NDArray;
+/**
+ * Element-wise natural exponential (e^x)
+ * @param x - Input array
+ * @returns Array of e^x values
+ */
+export declare function exp(x: NDArray): NDArray;
+/**
+ * Element-wise base-2 exponential (2^x)
+ * @param x - Input array
+ * @returns Array of 2^x values
+ */
+export declare function exp2(x: NDArray): NDArray;
+/**
+ * Element-wise exponential minus one (e^x - 1)
+ * More accurate than exp(x) - 1 for small x
+ * @param x - Input array
+ * @returns Array of expm1 values
+ */
+export declare function expm1(x: NDArray): NDArray;
+/**
+ * Element-wise natural logarithm (ln)
+ * @param x - Input array
+ * @returns Array of log values
+ */
+export declare function log(x: NDArray): NDArray;
+/**
+ * Element-wise base-2 logarithm
+ * @param x - Input array
+ * @returns Array of log2 values
+ */
+export declare function log2(x: NDArray): NDArray;
+/**
+ * Element-wise base-10 logarithm
+ * @param x - Input array
+ * @returns Array of log10 values
+ */
+export declare function log10(x: NDArray): NDArray;
+/**
+ * Element-wise natural logarithm of (1 + x)
+ * More accurate than log(1 + x) for small x
+ * @param x - Input array
+ * @returns Array of log1p values
+ */
+export declare function log1p(x: NDArray): NDArray;
+/**
+ * Logarithm of the sum of exponentials: log(exp(x1) + exp(x2))
+ * More numerically stable than computing the expression directly
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Array of logaddexp values
+ */
+export declare function logaddexp(x1: NDArray, x2: NDArray | number): NDArray;
+/**
+ * Logarithm base 2 of the sum of exponentials: log2(2^x1 + 2^x2)
+ * More numerically stable than computing the expression directly
+ * @param x1 - First input array
+ * @param x2 - Second input array or scalar
+ * @returns Array of logaddexp2 values
+ */
+export declare function logaddexp2(x1: NDArray, x2: NDArray | number): NDArray;
 /**
  * Element-wise absolute value
  * @param x - Input array
@@ -1866,6 +2068,108 @@ export declare function unpackbits(a: NDArray, axis?: number, count?: number, bi
  * einsum('ii->', a)
  */
 export declare function einsum(subscripts: string, ...operands: NDArray[]): NDArray | number | bigint;
+/**
+ * numpy.linalg module - Linear algebra functions
+ */
+export declare const linalg: {
+    /**
+     * Cross product of two vectors.
+     */
+    cross: (a: NDArray, b: NDArray, axisa?: number, axisb?: number, axisc?: number, axis?: number) => NDArray | number;
+    /**
+     * Compute the norm of a vector or matrix.
+     */
+    norm: (x: NDArray, ord?: number | "fro" | "nuc" | null, axis?: number | [number, number] | null, keepdims?: boolean) => NDArray | number;
+    /**
+     * Compute the vector norm.
+     */
+    vector_norm: (x: NDArray, ord?: number, axis?: number | null, keepdims?: boolean) => NDArray | number;
+    /**
+     * Compute the matrix norm.
+     */
+    matrix_norm: (x: NDArray, ord?: number | "fro" | "nuc", keepdims?: boolean) => NDArray | number;
+    /**
+     * QR decomposition.
+     */
+    qr: (a: NDArray, mode?: "reduced" | "complete" | "r" | "raw") => {
+        q: NDArray;
+        r: NDArray;
+    } | NDArray | {
+        h: NDArray;
+        tau: NDArray;
+    };
+    /**
+     * Cholesky decomposition.
+     */
+    cholesky: (a: NDArray, upper?: boolean) => NDArray;
+    /**
+     * Singular Value Decomposition.
+     */
+    svd: (a: NDArray, full_matrices?: boolean, compute_uv?: boolean) => {
+        u: NDArray;
+        s: NDArray;
+        vt: NDArray;
+    } | NDArray;
+    /**
+     * Compute the determinant of a matrix.
+     */
+    det: (a: NDArray) => number;
+    /**
+     * Compute the matrix inverse.
+     */
+    inv: (a: NDArray) => NDArray;
+    /**
+     * Solve a linear system.
+     */
+    solve: (a: NDArray, b: NDArray) => NDArray;
+    /**
+     * Least-squares solution to a linear matrix equation.
+     */
+    lstsq: (a: NDArray, b: NDArray, rcond?: number | null) => {
+        x: NDArray;
+        residuals: NDArray;
+        rank: number;
+        s: NDArray;
+    };
+    /**
+     * Compute the condition number.
+     */
+    cond: (a: NDArray, p?: number | "fro" | "nuc") => number;
+    /**
+     * Compute the matrix rank.
+     */
+    matrix_rank: (a: NDArray, tol?: number) => number;
+    /**
+     * Raise a square matrix to an integer power.
+     */
+    matrix_power: (a: NDArray, n: number) => NDArray;
+    /**
+     * Compute the Moore-Penrose pseudo-inverse.
+     */
+    pinv: (a: NDArray, rcond?: number) => NDArray;
+    /**
+     * Compute eigenvalues and eigenvectors.
+     */
+    eig: (a: NDArray) => {
+        w: NDArray;
+        v: NDArray;
+    };
+    /**
+     * Compute eigenvalues and eigenvectors of a Hermitian matrix.
+     */
+    eigh: (a: NDArray, UPLO?: "L" | "U") => {
+        w: NDArray;
+        v: NDArray;
+    };
+    /**
+     * Compute eigenvalues of a matrix.
+     */
+    eigvals: (a: NDArray) => NDArray;
+    /**
+     * Compute eigenvalues of a Hermitian matrix.
+     */
+    eigvalsh: (a: NDArray, UPLO?: "L" | "U") => NDArray;
+};
 /**
  * Take values from the input array by matching 1d index and data slices along axis.
  *
@@ -2011,4 +2315,226 @@ export declare function ravel_multi_index(multi_index: NDArray[], dims: number[]
  * @returns Tuple of coordinate arrays
  */
 export declare function unravel_index(indices: NDArray | number, shape: number[], order?: 'C' | 'F'): NDArray[];
+/**
+ * Return a sorted copy of an array
+ * @param a - Input array
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Sorted array
+ */
+export declare function sort(a: NDArray, axis?: number): NDArray;
+/**
+ * Returns the indices that would sort an array
+ * @param a - Input array
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Array of indices that sort the input array
+ */
+export declare function argsort(a: NDArray, axis?: number): NDArray;
+/**
+ * Perform an indirect stable sort using a sequence of keys
+ * @param keys - Array of NDArrays, the last key is the primary sort key
+ * @returns Array of indices that would sort the keys
+ */
+export declare function lexsort(keys: NDArray[]): NDArray;
+/**
+ * Partially sort an array
+ * @param a - Input array
+ * @param kth - Element index to partition by
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Partitioned array
+ */
+export declare function partition(a: NDArray, kth: number, axis?: number): NDArray;
+/**
+ * Returns indices that would partition an array
+ * @param a - Input array
+ * @param kth - Element index to partition by
+ * @param axis - Axis along which to sort. Default is -1 (last axis)
+ * @returns Array of indices
+ */
+export declare function argpartition(a: NDArray, kth: number, axis?: number): NDArray;
+/**
+ * Sort a complex array using the real part first, then the imaginary part
+ * For real arrays, returns a sorted 1D array
+ * @param a - Input array
+ * @returns Sorted 1D array
+ */
+export declare function sort_complex(a: NDArray): NDArray;
+/**
+ * Return the indices of the elements that are non-zero
+ * @param a - Input array
+ * @returns Tuple of arrays, one for each dimension
+ */
+export declare function nonzero(a: NDArray): NDArray[];
+/**
+ * Return indices of non-zero elements in flattened array
+ * @param a - Input array
+ * @returns Array of indices
+ */
+export declare function flatnonzero(a: NDArray): NDArray;
+/**
+ * Return elements from x or y depending on condition
+ * If only condition is given, returns indices where condition is true (like nonzero)
+ * @param condition - Boolean array or condition
+ * @param x - Values where condition is true (optional)
+ * @param y - Values where condition is false (optional)
+ * @returns Array with elements chosen from x or y, or indices if only condition given
+ */
+export declare function where(condition: NDArray, x?: NDArray, y?: NDArray): NDArray | NDArray[];
+/**
+ * Find indices where elements should be inserted to maintain order
+ * @param a - Input array (must be sorted in ascending order)
+ * @param v - Values to insert
+ * @param side - 'left' or 'right' side to insert
+ * @returns Indices where values should be inserted
+ */
+export declare function searchsorted(a: NDArray, v: NDArray, side?: 'left' | 'right'): NDArray;
+/**
+ * Return the elements of an array that satisfy some condition
+ * @param condition - Boolean array
+ * @param a - Input array
+ * @returns 1D array of elements where condition is true
+ */
+export declare function extract(condition: NDArray, a: NDArray): NDArray;
+/**
+ * Count number of non-zero values in the array
+ * @param a - Input array
+ * @param axis - Axis along which to count (optional)
+ * @returns Count of non-zero values
+ */
+export declare function count_nonzero(a: NDArray, axis?: number): NDArray | number;
+/**
+ * Round an array to the given number of decimals
+ * @param a - Input array
+ * @param decimals - Number of decimal places to round to (default: 0)
+ * @returns Rounded array
+ */
+export declare function around(a: NDArray, decimals?: number): NDArray;
+/**
+ * Return the ceiling of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise ceiling
+ */
+export declare function ceil(x: NDArray): NDArray;
+/**
+ * Round to nearest integer towards zero
+ * @param x - Input array
+ * @returns Array with values truncated towards zero
+ */
+export declare function fix(x: NDArray): NDArray;
+/**
+ * Return the floor of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise floor
+ */
+export declare function floor(x: NDArray): NDArray;
+/**
+ * Round elements of the array to the nearest integer
+ * @param x - Input array
+ * @returns Array with rounded integer values
+ */
+export declare function rint(x: NDArray): NDArray;
+/**
+ * Evenly round to the given number of decimals (alias for around)
+ * @param a - Input array
+ * @param decimals - Number of decimal places to round to (default: 0)
+ * @returns Rounded array
+ */
+export { around as round };
+/**
+ * Return the truncated value of the input, element-wise
+ * @param x - Input array
+ * @returns Element-wise truncated values
+ */
+export declare function trunc(x: NDArray): NDArray;
+/**
+ * Find the unique elements of an array
+ * @param ar - Input array
+ * @param returnIndex - If True, also return the indices of the first occurrences
+ * @param returnInverse - If True, also return the indices to reconstruct the original array
+ * @param returnCounts - If True, also return the number of times each unique value appears
+ * @returns Unique sorted values, and optionally indices/inverse/counts
+ */
+export declare function unique(ar: NDArray, returnIndex?: boolean, returnInverse?: boolean, returnCounts?: boolean): NDArray | {
+    values: NDArray;
+    indices?: NDArray;
+    inverse?: NDArray;
+    counts?: NDArray;
+};
+/**
+ * Test whether each element of a 1-D array is also present in a second array
+ * @param ar1 - Input array
+ * @param ar2 - Test values
+ * @returns Boolean array indicating membership
+ */
+export declare function in1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the intersection of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of common and unique elements
+ */
+export declare function intersect1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Test whether each element of an ND array is also present in a second array
+ * @param element - Input array
+ * @param testElements - Test values
+ * @returns Boolean array indicating membership (same shape as element)
+ */
+export declare function isin(element: NDArray, testElements: NDArray): NDArray;
+/**
+ * Find the set difference of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of values in ar1 that are not in ar2
+ */
+export declare function setdiff1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the set exclusive-or of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of values that are in only one array
+ */
+export declare function setxor1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Find the union of two arrays
+ * @param ar1 - First input array
+ * @param ar2 - Second input array
+ * @returns Sorted 1D array of unique values from both arrays
+ */
+export declare function union1d(ar1: NDArray, ar2: NDArray): NDArray;
+/**
+ * Calculate the n-th discrete difference along the given axis
+ * @param a - Input array
+ * @param n - Number of times values are differenced (default: 1)
+ * @param axis - Axis along which to compute difference (default: -1)
+ * @returns Array of differences
+ */
+export declare function diff(a: NDArray, n?: number, axis?: number): NDArray;
+/**
+ * The differences between consecutive elements of a flattened array
+ * @param ary - Input array
+ * @param to_end - Number(s) to append at the end
+ * @param to_begin - Number(s) to prepend at the beginning
+ * @returns Array of differences
+ */
+export declare function ediff1d(ary: NDArray, to_end?: number[] | null, to_begin?: number[] | null): NDArray;
+/**
+ * Return the gradient of an N-dimensional array
+ * The gradient is computed using second order accurate central differences
+ * in the interior and first order accurate one-sided differences at the boundaries.
+ * @param f - Input array
+ * @param varargs - Spacing between values (scalar or array per dimension)
+ * @param axis - Axis or axes along which to compute gradient
+ * @returns Array of gradients (one per axis) or single gradient
+ */
+export declare function gradient(f: NDArray, varargs?: number | number[], axis?: number | number[] | null): NDArray | NDArray[];
+/**
+ * Return the cross product of two (arrays of) vectors
+ * @param a - First input array
+ * @param b - Second input array
+ * @param axisa - Axis of a that defines the vector(s) (default: -1)
+ * @param axisb - Axis of b that defines the vector(s) (default: -1)
+ * @param axisc - Axis of c containing the cross product (default: -1)
+ * @returns Cross product array
+ */
+export declare function cross(a: NDArray, b: NDArray, axisa?: number, axisb?: number, axisc?: number): NDArray;
 //# sourceMappingURL=ndarray.d.ts.map

package/dist/types/index.d.ts

@@ -3,7 +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, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, } 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, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, linalg, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, flatnonzero, where, searchsorted, extract, count_nonzero, around, ceil, fix, floor, rint, round, trunc, unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, diff, ediff1d, gradient, cross, } 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

@@ -1,17 +1,18 @@
 /**
  * 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.
+ * This module provides parsing and serialization for NPY, NPZ, and text formats.
+ * These functions work with bytes/strings and are environment-agnostic.
  *
  * For file system operations (save/load), use the Node.js-specific entry point:
- *   import { save, load } from 'numpy-ts/node';
+ *   import { save, load, loadtxt, savetxt } from 'numpy-ts/node';
  *
- * For browser usage, use fetch or FileReader to get the bytes, then use these functions.
+ * For browser usage, use fetch or FileReader to get the bytes/text, 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';
+export { parseTxt, genfromtxt, fromregex, serializeTxt, type ParseTxtOptions, type SerializeTxtOptions, } from './txt';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * Text I/O module for numpy-ts
+ *
+ * Provides parsing and serialization for delimited text formats (CSV, TSV, etc.).
+ * These functions work with strings and are environment-agnostic.
+ *
+ * For file system operations, use the Node.js-specific entry point:
+ *   import { loadtxt, savetxt } from 'numpy-ts/node';
+ */
+export { parseTxt, genfromtxt, fromregex, type ParseTxtOptions } from './parser';
+export { serializeTxt, type SerializeTxtOptions } from './serializer';
+//# sourceMappingURL=index.d.ts.map