numpy-ts 1.1.0 → 1.3.0

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

@@ -3,6 +3,7 @@ import { NDArrayCore } from '../common/ndarray-core';
 import { Complex } from '../common/complex';
 import type { DType, TypedArray } from '../core/types';
 export type { DType, TypedArray } from '../core/types';
+export type { NDIndex } from '../core/advanced';
 export { NDArray, meshgrid } from './ndarray';
 export { NDArrayCore } from '../common/ndarray-core';
 export { Complex } from '../common/complex';
@@ -25,7 +26,7 @@ export declare function iindex(a: NDArrayCore, indices: NDArrayCore | number[] |
  */
 export declare function bindex(a: NDArrayCore, mask: NDArrayCore, axis?: number): NDArray;
 export declare function select(condlist: NDArrayCore[], choicelist: NDArrayCore[], defaultVal?: number): NDArray;
-export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArray;
+export declare function indices(dimensions: number[], dtype?: string): NDArray;
 export declare function ravel_multi_index(multi_index: NDArrayCore[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArray;
 export declare function unravel_index(indices: NDArrayCore | number, shape: number[]): NDArray[];
 export declare function diag_indices(n: number, ndim?: number): NDArray[];
@@ -34,9 +35,16 @@ export declare function tril_indices(n: number, k?: number, m?: number): NDArray
 export declare function tril_indices_from(a: NDArrayCore, k?: number): NDArray[];
 export declare function triu_indices(n: number, k?: number, m?: number): NDArray[];
 export declare function triu_indices_from(a: NDArrayCore, k?: number): NDArray[];
-export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArrayCore, k?: number): NDArray[];
+export declare function mask_indices(n: number, mask_func: (m: NDArrayCore, k: number) => NDArrayCore, k?: number): NDArray[];
 export declare function apply_along_axis(func1d: (arr: NDArrayCore) => NDArrayCore | number, axis: number, arr: NDArrayCore): NDArray;
 export declare function apply_over_axes(func: (arr: NDArrayCore, axis: number) => NDArrayCore, a: NDArrayCore, axes: number[]): NDArray;
+/**
+ * Vectorized multi-dimensional indexing (dask.vindex semantics).
+ *
+ * Integer-array subspace dimensions come first in the output, followed by
+ * slice dimensions in their original order.
+ */
+export declare function vindex(a: NDArrayCore, ...indices: (number | string | number[] | NDArrayCore)[]): NDArray;
 /** Add arguments element-wise */
 export declare function add(x1: NDArrayCore, x2: NDArrayCore | number): NDArray;
 /** Subtract arguments element-wise */
@@ -170,7 +178,7 @@ export declare function zeros(shape: number[], dtype?: DType): NDArray;
  */
 export declare function ones(shape: number[], dtype?: DType): NDArray;
 /**
- * Create an uninitialized array (zeros in JS)
+ * Create an uninitialized array
  */
 export declare function empty(shape: number[], dtype?: DType): NDArray;
 /**
@@ -449,7 +457,10 @@ export declare function floor(x: NDArrayCore): NDArray;
 export declare function rint(x: NDArrayCore): NDArray;
 /** Truncate toward zero */
 export declare function trunc(x: NDArrayCore): NDArray;
-/** Test if elements in ar1 are in ar2 (deprecated, use isin) */
+/**
+ * Test if elements in ar1 are in ar2.
+ * @deprecated Use {@link isin} instead. `in1d` follows NumPy's deprecation and will be removed in a future release.
+ */
 export declare function in1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArray;
 /** Find intersection of two arrays */
 export declare function intersect1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArray;
@@ -564,7 +575,7 @@ export declare function cov(m: NDArrayCore, y?: NDArrayCore, rowvar?: boolean, b
 /** Correlation coefficients */
 export declare function corrcoef(x: NDArrayCore, y?: NDArrayCore, rowvar?: boolean): NDArray;
 /** Integrate using trapezoidal rule */
-export declare function trapezoid(y: NDArrayCore, x?: NDArrayCore, dx?: number, axis?: number): NDArray | number;
+export declare function trapezoid(y: NDArrayCore, x?: NDArrayCore, dx?: number, axis?: number): NDArray | number | Complex;
 /** Sine of array elements */
 export declare function sin(x: NDArrayCore): NDArray;
 /** Cosine of array elements */
@@ -601,5 +612,7 @@ export declare function arcsinh(x: NDArrayCore): NDArray;
 export declare function arccosh(x: NDArrayCore): NDArray;
 /** Inverse hyperbolic tangent */
 export declare function arctanh(x: NDArrayCore): NDArray;
-export { broadcast_arrays, broadcast_shapes, put, put_along_axis, place, putmask, copyto, ix_, fill_diagonal, array_equal, array_equiv, may_share_memory, shares_memory, geterr, seterr, pow, abs, true_divide, conjugate, array2string, array_repr, array_str, set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, gradient, einsum, einsum_path, vdot, linalg, iscomplexobj, isrealobj, isfortran, isscalar, iterable, isdtype, promote_types, allclose, amax, amin, var_, cumulative_sum, cumulative_prod, round_, unique, unique_all, unique_counts, unique_inverse, split, array_split, vsplit, hsplit, dsplit, atleast_1d, atleast_2d, atleast_3d, row_stack, where, searchsorted, count_nonzero, histogram, histogram2d, histogramdd, histogram_bin_edges, asin, acos, atan, atan2, asinh, acosh, atanh, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill, } from '../core';
+export { broadcast_arrays, broadcast_shapes, put, put_along_axis, place, putmask, copyto, ix_, fill_diagonal, array_equal, array_equiv, may_share_memory, shares_memory, geterr, seterr, pow, abs, true_divide, conjugate, array2string, array_repr, array_str, set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, gradient, einsum, einsum_path, vdot, linalg, iscomplexobj, isrealobj, isfortran, isscalar, iterable, isdtype, promote_types, allclose, amax, amin, var_, cumulative_sum, cumulative_prod, unique, unique_all, unique_counts, unique_inverse, split, array_split, vsplit, hsplit, dsplit, atleast_1d, atleast_2d, atleast_3d, row_stack, where, searchsorted, count_nonzero, histogram, histogram2d, histogramdd, histogram_bin_edges, asin, acos, atan, atan2, asinh, acosh, atanh, can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill, } from '../core';
+export { wasmConfig } from '../common/wasm/config';
+export { configureWasm } from '../common/wasm/runtime';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts

@@ -22,6 +22,7 @@
 export { Complex, type ComplexInput } from './common/complex';
 export { NDArray } from './full';
 export { NDArrayCore } from './common/ndarray-core';
+export { hasFloat16 } from './common/dtype';
 export { zeros, ones, empty, full, array, arange, linspace, logspace, geomspace, eye, identity, asarray, zeros_like, ones_like, empty_like, full_like, copy, asanyarray, asarray_chkfinite, ascontiguousarray, asfortranarray, require, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, } from './full';
 export { add, subtract, multiply, divide, true_divide, floor_divide, mod, sqrt, power, exp, exp2, expm1, log, log2, log10, log1p, logaddexp, logaddexp2, absolute, negative, sign, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, float_power, fmod, frexp, gcd, lcm, ldexp, modf, clip, maximum, minimum, fmax, fmin, nan_to_num, interp, unwrap, sinc, i0, } from './full';
 export { power as pow, absolute as abs } from './full';
@@ -36,14 +37,15 @@ export { logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isn
 export { sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, } from './full';
 export { bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, } from './full';
 export { bitwise_not as bitwise_invert, left_shift as bitwise_left_shift, right_shift as bitwise_right_shift, } from './full';
-export { around, round_, ceil, fix, floor, rint, trunc } from './full';
+export { around, ceil, fix, floor, rint, trunc } from './full';
 export { around as round } from './full';
 export { unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, } from './full';
 export { bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, } from './full';
 export { diff, ediff1d, gradient } from './full';
 export { real, imag, conj, angle } from './full';
 export { conj as conjugate } from './full';
-export { broadcast_to, broadcast_arrays, broadcast_shapes, take, put, iindex, bindex, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, fill, item, tolist, tobytes, byteswap, view, tofile, } from './full';
+export { broadcast_to, broadcast_arrays, broadcast_shapes, take, put, iindex, bindex, vindex, copyto, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, fill_diagonal, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, fill, item, tolist, tobytes, byteswap, view, tofile, } from './full';
+export type { NDIndex } from './full';
 export { apply_along_axis, apply_over_axes, may_share_memory, shares_memory, ndim, shape, size, geterr, seterr, } from './full';
 export { array2string, array_repr, array_str, base_repr, binary_repr, format_float_positional, format_float_scientific, get_printoptions, set_printoptions, printoptions, } from './full';
 export { can_cast, common_type, result_type, min_scalar_type, issubdtype, typename, mintypecode, } from './full';
@@ -54,6 +56,7 @@ export type { NpzSerializeOptions } from './io/npz/serializer';
 export type { ParseTxtOptions } from './io/txt/parser';
 export type { SerializeTxtOptions } from './io/txt/serializer';
 export { wasmConfig } from './common/wasm/config';
+export { configureWasm } from './common/wasm/runtime';
 export { serializeNpy } from './io/npy/serializer';
 export { serializeNpz, serializeNpzSync } from './io/npz/serializer';
 export { serializeTxt } from './io/txt/serializer';
@@ -78,6 +81,7 @@ export declare function loadNpzSync(buffer: ArrayBuffer | Uint8Array, options?:
 export declare function parseTxt(text: string, options?: ParseTxtOptionsType): NDArrayClass;
 export declare function genfromtxt(text: string, options?: ParseTxtOptionsType): NDArrayClass;
 export declare function fromregex(text: string, regexp: RegExp | string, dtype?: DTypeIO): NDArrayClass;
+export { type LoadOptions, type SaveNpzOptions, type LoadTxtOptions, type SaveTxtOptions, loadNpy, loadNpySync, saveNpy, saveNpySync, loadNpzFile, loadNpzFileSync, saveNpz as saveNpzFile, saveNpzSync as saveNpzFileSync, savez, savez_compressed, load, loadSync, save, saveSync, loadtxt, loadtxtSync, savetxt, savetxtSync, genfromtxt as genfromtxtFile, genfromtxtSync as genfromtxtFileSync, fromregex as fromregexFile, fromregexSync as fromregexFileSync, } from './io/file-ops';
 import * as randomOps from './common/ops/random';
 import { ArrayStorage } from './common/storage';
 import { NDArray as NDArrayClass } from './full';
@@ -88,7 +92,19 @@ export declare const random: {
     set_state: typeof randomOps.set_state;
     get_bit_generator: typeof randomOps.get_bit_generator;
     set_bit_generator: typeof randomOps.set_bit_generator;
-    default_rng: typeof randomOps.default_rng;
+    default_rng: (seedValue?: number) => {
+        random: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        integers: (low: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        choice: (a: number | (ArrayStorage | NDArrayCore | NDArrayClass), size?: number | number[], replace?: boolean, p?: (ArrayStorage | NDArrayCore | NDArrayClass) | number[]) => number | ArrayStorage | NDArrayClass;
+        permutation: (x: number | (ArrayStorage | NDArrayCore | NDArrayClass)) => ArrayStorage | NDArrayClass;
+        shuffle: (x: ArrayStorage | NDArrayCore | NDArrayClass) => void;
+        exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+        binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
+    };
     Generator: typeof randomOps.Generator;
     random: (size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     rand: (...shape: number[]) => number | ArrayStorage | NDArrayClass;
@@ -136,7 +152,7 @@ export declare const random: {
     vonmises: (mu: number, kappa: number, size?: number | number[]) => number | ArrayStorage | NDArrayClass;
     choice: (a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]) => number | ArrayStorage | NDArrayClass;
     permutation: (x: number | ArrayStorage) => ArrayStorage | NDArrayClass;
-    shuffle: typeof randomOps.shuffle;
+    shuffle: (x: NDArrayClass | NDArrayCore | ArrayStorage) => void;
 };
 import { NDArrayCore } from './common/ndarray-core';
 type ArrayInput = NDArrayClass | NDArrayCore | ArrayStorage;

package/dist/types/io/file-ops.d.ts

@@ -0,0 +1,269 @@
+/**
+ * File IO operations for numpy-ts.
+ *
+ * These functions read/write files using the runtime fs abstraction from filesystem.ts.
+ * They work in Node.js, Bun, and Deno, and throw clear errors in the browser.
+ */
+import { NDArray } from '../full/ndarray';
+import type { NpzParseOptions } from './npz/parser';
+import { type NpzSerializeOptions, type NpzArraysInput } from './npz/serializer';
+import { type ParseTxtOptions, type SerializeTxtOptions } from './txt';
+import type { DType } from '../common/dtype';
+interface NpzParseResultNDArray {
+    arrays: Map<string, NDArray>;
+    skipped: string[];
+    errors: Map<string, string>;
+}
+/**
+ * Options for loading NPY/NPZ files
+ */
+export interface LoadOptions extends NpzParseOptions {
+    /**
+     * If true, allow loading .npy files.
+     * Default: true
+     */
+    allowNpy?: boolean;
+}
+/**
+ * Options for saving NPZ files
+ */
+export type SaveNpzOptions = NpzSerializeOptions;
+/**
+ * Options for loadtxt
+ */
+export type LoadTxtOptions = ParseTxtOptions;
+/**
+ * Options for savetxt
+ */
+export type SaveTxtOptions = SerializeTxtOptions;
+/**
+ * Load an NDArray from a .npy file
+ *
+ * @param path - Path to the .npy file
+ * @returns The loaded NDArray
+ */
+export declare function loadNpy(path: string): Promise<NDArray>;
+/**
+ * Synchronously load an NDArray from a .npy file
+ *
+ * @param path - Path to the .npy file
+ * @returns The loaded NDArray
+ */
+export declare function loadNpySync(path: string): NDArray;
+/**
+ * Save an NDArray to a .npy file
+ *
+ * @param path - Path to save the .npy file
+ * @param arr - The NDArray to save
+ */
+export declare function saveNpy(path: string, arr: NDArray): Promise<void>;
+/**
+ * Synchronously save an NDArray to a .npy file
+ *
+ * @param path - Path to save the .npy file
+ * @param arr - The NDArray to save
+ */
+export declare function saveNpySync(path: string, arr: NDArray): void;
+/**
+ * Load arrays from a .npz file
+ *
+ * @param path - Path to the .npz file
+ * @param options - Load options
+ * @returns Object with array names as keys
+ */
+export declare function loadNpzFile(path: string, options?: NpzParseOptions): Promise<NpzParseResultNDArray>;
+/**
+ * Synchronously load arrays from a .npz file
+ *
+ * Note: Only works if the NPZ file is not DEFLATE compressed.
+ *
+ * @param path - Path to the .npz file
+ * @param options - Load options
+ * @returns Object with array names as keys
+ */
+export declare function loadNpzFileSync(path: string, options?: NpzParseOptions): NpzParseResultNDArray;
+/**
+ * Save arrays to a .npz file
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save:
+ *   - Array of NDArrays (positional, named arr_0, arr_1, etc.)
+ *   - Map of names to NDArrays
+ *   - Object with names as keys
+ * @param options - Save options
+ */
+export declare function saveNpz(path: string, arrays: NpzArraysInput, options?: SaveNpzOptions): Promise<void>;
+/**
+ * Synchronously save arrays to a .npz file (no compression)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save (same types as saveNpz)
+ */
+export declare function saveNpzSync(path: string, arrays: NpzArraysInput): void;
+/**
+ * Load an array or arrays from a .npy or .npz file
+ *
+ * This is a convenience function that auto-detects the file format based on extension.
+ *
+ * @param path - Path to the file
+ * @param options - Load options
+ * @returns NDArray for .npy files, or NpzParseResult for .npz files
+ */
+export declare function load(path: string, options?: LoadOptions): Promise<NDArray | NpzParseResultNDArray>;
+/**
+ * Synchronously load an array or arrays from a .npy or .npz file
+ *
+ * @param path - Path to the file
+ * @param options - Load options
+ * @returns NDArray for .npy files, or NpzParseResult for .npz files
+ */
+export declare function loadSync(path: string, options?: LoadOptions): NDArray | NpzParseResultNDArray;
+/**
+ * Save an array to a .npy file
+ *
+ * @param path - Path to save the file (should end with .npy)
+ * @param arr - The NDArray to save
+ */
+export declare function save(path: string, arr: NDArray): Promise<void>;
+/**
+ * Synchronously save an array to a .npy file
+ *
+ * @param path - Path to save the file (should end with .npy)
+ * @param arr - The NDArray to save
+ */
+export declare function saveSync(path: string, arr: NDArray): void;
+/**
+ * Save multiple arrays to a .npz file (like np.savez)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save:
+ *   - Array of NDArrays: named arr_0, arr_1, etc. (like np.savez positional args)
+ *   - Object/Map with names as keys (like np.savez keyword args)
+ *
+ * @example
+ * // Positional arrays
+ * await savez('data.npz', [arr1, arr2])  // saved as arr_0, arr_1
+ *
+ * // Named arrays
+ * await savez('data.npz', { x: arr1, y: arr2 })
+ */
+export declare function savez(path: string, arrays: NpzArraysInput): Promise<void>;
+/**
+ * Save multiple arrays to a compressed .npz file (like np.savez_compressed)
+ *
+ * @param path - Path to save the .npz file
+ * @param arrays - Arrays to save (same input types as savez)
+ */
+export declare function savez_compressed(path: string, arrays: NpzArraysInput): Promise<void>;
+/**
+ * Load data from a text file.
+ *
+ * Each row in the text file must have the same number of values.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ *
+ * @example
+ * ```typescript
+ * // Load a CSV file
+ * const arr = await loadtxt('data.csv', { delimiter: ',' });
+ *
+ * // Load with specific columns
+ * const arr = await loadtxt('data.txt', { usecols: [0, 2] });
+ *
+ * // Skip header rows
+ * const arr = await loadtxt('data.txt', { skiprows: 1 });
+ * ```
+ */
+export declare function loadtxt(path: string, options?: LoadTxtOptions): Promise<NDArray>;
+/**
+ * Synchronously load data from a text file.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ */
+export declare function loadtxtSync(path: string, options?: LoadTxtOptions): NDArray;
+/**
+ * Save an array to a text file.
+ *
+ * @param path - Path to save the text file
+ * @param arr - The array to save (must be 1D or 2D)
+ * @param options - Save options
+ *
+ * @example
+ * ```typescript
+ * // Save as CSV
+ * await savetxt('data.csv', arr, { delimiter: ',' });
+ *
+ * // Save with custom format
+ * await savetxt('data.txt', arr, { fmt: '%.2f', delimiter: '\t' });
+ *
+ * // Save with header
+ * await savetxt('data.txt', arr, { header: 'x y z' });
+ * ```
+ */
+export declare function savetxt(path: string, arr: NDArray, options?: SaveTxtOptions): Promise<void>;
+/**
+ * Synchronously save an array to a text file.
+ *
+ * @param path - Path to save the text file
+ * @param arr - The array to save (must be 1D or 2D)
+ * @param options - Save options
+ */
+export declare function savetxtSync(path: string, arr: NDArray, options?: SaveTxtOptions): void;
+/**
+ * Load data from a text file with more flexible handling.
+ *
+ * Similar to loadtxt but handles missing values more gracefully.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ *
+ * @example
+ * ```typescript
+ * // Load file with missing values
+ * const arr = await genfromtxt('data.csv', {
+ *   delimiter: ',',
+ *   missing_values: ['NA', ''],
+ *   filling_values: 0
+ * });
+ * ```
+ */
+export declare function genfromtxt(path: string, options?: LoadTxtOptions): Promise<NDArray>;
+/**
+ * Synchronously load data from a text file with more flexible handling.
+ *
+ * @param path - Path to the text file
+ * @param options - Load options
+ * @returns NDArray with the loaded data
+ */
+export declare function genfromtxtSync(path: string, options?: LoadTxtOptions): NDArray;
+/**
+ * Load data from a text file using regular expressions.
+ *
+ * @param path - Path to the text file
+ * @param regexp - Regular expression with capture groups for extracting values
+ * @param dtype - Data type of the resulting array (default: 'float64')
+ * @returns NDArray with the extracted data
+ *
+ * @example
+ * ```typescript
+ * // Extract x,y pairs from "Point: x=1.0, y=2.0" format
+ * const arr = await fromregex('points.txt', /x=([\d.]+), y=([\d.]+)/);
+ * ```
+ */
+export declare function fromregex(path: string, regexp: RegExp | string, dtype?: DType): Promise<NDArray>;
+/**
+ * Synchronously load data from a text file using regular expressions.
+ *
+ * @param path - Path to the text file
+ * @param regexp - Regular expression with capture groups for extracting values
+ * @param dtype - Data type of the resulting array (default: 'float64')
+ * @returns NDArray with the extracted data
+ */
+export declare function fromregexSync(path: string, regexp: RegExp | string, dtype?: DType): NDArray;
+export {};
+//# sourceMappingURL=file-ops.d.ts.map

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

@@ -0,0 +1,21 @@
+/**
+ * Runtime filesystem abstraction for cross-platform file IO.
+ *
+ * Pre-loads `node:fs` and `node:fs/promises` asynchronously at module load
+ * in Node-like environments. Both getFs() and getFsSync() read from this cache.
+ * In browsers, all IO functions throw a helpful error.
+ */
+type FsPromises = typeof import('node:fs/promises');
+type FsSync = typeof import('node:fs');
+/**
+ * Get the async fs module (`node:fs/promises`).
+ * Caches the result after the first successful resolution.
+ */
+export declare function getFs(): Promise<FsPromises>;
+/**
+ * Get the sync fs module (`node:fs`).
+ * Reads from the cache populated at module load time or by a prior getFs() call.
+ */
+export declare function getFsSync(): FsSync;
+export {};
+//# sourceMappingURL=filesystem.d.ts.map